diff --git a/src/armnn/LoadedNetwork.cpp b/src/armnn/LoadedNetwork.cpp
index 24d119c..3464fb0 100644
--- a/src/armnn/LoadedNetwork.cpp
+++ b/src/armnn/LoadedNetwork.cpp
@@ -92,10 +92,11 @@
             auto createBackend = BackendRegistryInstance().GetFactory(backend);
             auto it = m_Backends.emplace(std::make_pair(backend, createBackend()));
 
-            auto memoryManager   = it.first->second->CreateMemoryManager();
-            auto workloadFactory = it.first->second->CreateWorkloadFactory(std::move(memoryManager));
+            IBackendInternal::IMemoryManagerSharedPtr memoryManager = it.first->second->CreateMemoryManager();
+            auto workloadFactory = it.first->second->CreateWorkloadFactory(memoryManager);
 
-            m_WorkloadFactories.emplace(std::make_pair(backend, std::move(workloadFactory)));
+            m_WorkloadFactories.emplace(std::make_pair(backend,
+                std::make_pair(std::move(workloadFactory), memoryManager)));
         }
         layer->CreateTensorHandles(m_OptimizedNetwork->GetGraph(), GetWorkloadFactory(*layer));
     }
@@ -182,7 +183,7 @@
             CHECK_LOCATION());
     }
 
-    workloadFactory = it->second.get();
+    workloadFactory = it->second.first.get();
 
     BOOST_ASSERT_MSG(workloadFactory, "No workload factory");
 
@@ -416,7 +417,11 @@
     }
     for (auto&& workloadFactory : m_WorkloadFactories)
     {
-        workloadFactory.second->Acquire();
+        IBackendInternal::IMemoryManagerSharedPtr memoryManager = workloadFactory.second.second;
+        if (memoryManager)
+        {
+            memoryManager->Acquire();
+        }
     }
     m_IsWorkingMemAllocated = true;
 }
@@ -431,7 +436,11 @@
     // Informs the memory managers to release memory in it's respective memory group
     for (auto&& workloadFactory : m_WorkloadFactories)
     {
-        workloadFactory.second->Release();
+        IBackendInternal::IMemoryManagerSharedPtr memoryManager = workloadFactory.second.second;
+        if (memoryManager)
+        {
+            memoryManager->Release();
+        }
     }
     m_IsWorkingMemAllocated = false;
 }
diff --git a/src/armnn/LoadedNetwork.hpp b/src/armnn/LoadedNetwork.hpp
index 65dd4ec..03a741f 100644
--- a/src/armnn/LoadedNetwork.hpp
+++ b/src/armnn/LoadedNetwork.hpp
@@ -62,7 +62,11 @@
     const IWorkloadFactory& GetWorkloadFactory(const Layer& layer) const;
 
     using BackendPtrMap = std::unordered_map<BackendId, IBackendInternalUniquePtr>;
-    using WorkloadFactoryMap = std::unordered_map<BackendId, IBackendInternal::IWorkloadFactoryPtr>;
+
+    using WorkloadFactoryWithMemoryManager =
+        std::pair<IBackendInternal::IWorkloadFactoryPtr, IBackendInternal::IMemoryManagerSharedPtr>;
+
+    using WorkloadFactoryMap = std::unordered_map<BackendId, WorkloadFactoryWithMemoryManager>;
 
     BackendPtrMap       m_Backends;
     WorkloadFactoryMap  m_WorkloadFactories;
diff --git a/src/armnn/test/UnitTests.hpp b/src/armnn/test/UnitTests.hpp
index 44b737c..f489ca0 100644
--- a/src/armnn/test/UnitTests.hpp
+++ b/src/armnn/test/UnitTests.hpp
@@ -66,8 +66,10 @@
     std::unique_ptr<armnn::Profiler> profiler = std::make_unique<armnn::Profiler>();
     armnn::ProfilerManager::GetInstance().RegisterProfiler(profiler.get());
 
-    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory();
-    auto testResult = (*testFunction)(workloadFactory, args...);
+    auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
+    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);
+
+    auto testResult = (*testFunction)(workloadFactory, memoryManager, args...);
     CompareTestResultIfSupported(testName, testResult);
 }
 
@@ -80,9 +82,12 @@
 template<typename FactoryType, typename TFuncPtr, typename... Args>
 void CompareRefTestFunction(const char* testName, TFuncPtr testFunction, Args... args)
 {
-    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory();
+    auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
+    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);
+
     armnn::RefWorkloadFactory refWorkloadFactory;
-    auto testResult = (*testFunction)(workloadFactory, refWorkloadFactory, args...);
+
+    auto testResult = (*testFunction)(workloadFactory, memoryManager, refWorkloadFactory, args...);
     CompareTestResultIfSupported(testName, testResult);
 }
 
diff --git a/src/backends/aclCommon/test/MemCopyTestImpl.hpp b/src/backends/aclCommon/test/MemCopyTestImpl.hpp
index 763a3f7..4247cc5 100644
--- a/src/backends/aclCommon/test/MemCopyTestImpl.hpp
+++ b/src/backends/aclCommon/test/MemCopyTestImpl.hpp
@@ -4,6 +4,8 @@
 //
 #pragma once
 
+#include <backendsCommon/IBackendInternal.hpp>
+
 #include <backendsCommon/test/LayerTests.hpp>
 #include <backendsCommon/test/TensorCopyUtils.hpp>
 #include <backendsCommon/test/WorkloadFactoryHelper.hpp>
@@ -76,8 +78,14 @@
 template<typename SrcWorkloadFactory, typename DstWorkloadFactory>
 LayerTestResult<float, 4> MemCopyTest(bool withSubtensors)
 {
-    SrcWorkloadFactory srcWorkloadFactory = WorkloadFactoryHelper<SrcWorkloadFactory>::GetFactory();
-    DstWorkloadFactory dstWorkloadFactory = WorkloadFactoryHelper<DstWorkloadFactory>::GetFactory();
+    armnn::IBackendInternal::IMemoryManagerSharedPtr srcMemoryManager =
+        WorkloadFactoryHelper<SrcWorkloadFactory>::GetMemoryManager();
+
+    armnn::IBackendInternal::IMemoryManagerSharedPtr dstMemoryManager =
+        WorkloadFactoryHelper<DstWorkloadFactory>::GetMemoryManager();
+
+    SrcWorkloadFactory srcWorkloadFactory = WorkloadFactoryHelper<SrcWorkloadFactory>::GetFactory(srcMemoryManager);
+    DstWorkloadFactory dstWorkloadFactory = WorkloadFactoryHelper<DstWorkloadFactory>::GetFactory(dstMemoryManager);
 
     return MemCopyTest(srcWorkloadFactory, dstWorkloadFactory, withSubtensors);
 }
diff --git a/src/backends/backendsCommon/WorkloadFactory.hpp b/src/backends/backendsCommon/WorkloadFactory.hpp
index e3be9f5..cd1ca25 100644
--- a/src/backends/backendsCommon/WorkloadFactory.hpp
+++ b/src/backends/backendsCommon/WorkloadFactory.hpp
@@ -25,12 +25,6 @@
 
     virtual const BackendId& GetBackendId() const = 0;
 
-    /// Inform the memory manager to release the memory
-    virtual void Release() { }
-
-    /// Inform the memory manager to acquire memory
-    virtual void Acquire() { }
-
     static bool IsLayerSupported(const BackendId& backendId,
                                  const IConnectableLayer& layer,
                                  Optional<DataType> dataType,
diff --git a/src/backends/backendsCommon/test/ActivationTestImpl.hpp b/src/backends/backendsCommon/test/ActivationTestImpl.hpp
index 3b3ee93..46c700c 100644
--- a/src/backends/backendsCommon/test/ActivationTestImpl.hpp
+++ b/src/backends/backendsCommon/test/ActivationTestImpl.hpp
@@ -12,6 +12,7 @@
 #include <armnn/TypesUtils.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
 #include <test/TensorHelpers.hpp>
@@ -19,12 +20,21 @@
 #include <algorithm>
 
 template<typename T>
-LayerTestResult<T, 4> BoundedReLuTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                        float upperBound, float lowerBound,
-                                        float inputScale, int32_t inputOffset, float outputScale, int32_t outputOffset,
-                                        const std::vector<T>& inputData, const std::vector<T>& outputExpectedData,
-                                        unsigned int inputWidth, unsigned int inputHeight,
-                                        unsigned int inputChannels, unsigned int inputBatchSize)
+LayerTestResult<T, 4> BoundedReLuTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float upperBound,
+    float lowerBound,
+    float inputScale,
+    int32_t inputOffset,
+    float outputScale,
+    int32_t outputOffset,
+    const std::vector<T>& inputData,
+    const std::vector<T>& outputExpectedData,
+    unsigned int inputWidth,
+    unsigned int inputHeight,
+    unsigned int inputChannels,
+    unsigned int inputBatchSize)
 {
     unsigned int outputWidth = inputWidth;
     unsigned int outputHeight = inputHeight;
@@ -79,7 +89,9 @@
     return result;
 }
 
-LayerTestResult<float, 4> BoundedReLuUpperAndLowerBoundTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> BoundedReLuUpperAndLowerBoundTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int inputWidth = 4u;
     unsigned int inputHeight = 5u;
@@ -103,11 +115,14 @@
      0.999f,       1.0f,    0.89f,      1.0f,
     };
 
-    return BoundedReLuTestCommon(workloadFactory, 1.0f, -1.0f, 1.0f, 0, 1.0f, 0, input, output,
-                                 inputWidth, inputHeight, inputChannels, inputBatchSize);
+    return BoundedReLuTestCommon(
+        workloadFactory, memoryManager, 1.0f, -1.0f, 1.0f, 0, 1.0f, 0, input, output,
+        inputWidth, inputHeight, inputChannels, inputBatchSize);
 }
 
-LayerTestResult<float, 4> BoundedReLuUpperBoundOnlyTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> BoundedReLuUpperBoundOnlyTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int inputWidth = 4u;
     unsigned int inputHeight = 5u;
@@ -131,11 +146,14 @@
      0.999f,       1.2f,    0.89f,       6.0f,
     };
 
-    return BoundedReLuTestCommon(workloadFactory, 6.0f, 0.0f, 1.0f, 0, 1.0f, 0, input, output,
-                                 inputWidth, inputHeight, inputChannels, inputBatchSize);
+    return BoundedReLuTestCommon(
+        workloadFactory, memoryManager, 6.0f, 0.0f, 1.0f, 0, 1.0f, 0, input, output,
+        inputWidth, inputHeight, inputChannels, inputBatchSize);
 }
 
-LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperBoundOnlyTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperBoundOnlyTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int inputWidth     = 3u;
     unsigned int inputHeight    = 2u;
@@ -158,13 +176,15 @@
     float outputScale    = 6.0f / 255.0f;
     int32_t outputOffset = 0;
 
-    return BoundedReLuTestCommon(workloadFactory, 6.0f, 0.0f,
+    return BoundedReLuTestCommon(workloadFactory, memoryManager, 6.0f, 0.0f,
                                  inputScale, inputOffset, outputScale, outputOffset,
                                  input, output,
                                  inputWidth, inputHeight, inputChannels, inputBatchSize);
 }
 
-LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperAndLowerBoundTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperAndLowerBoundTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int inputWidth     = 3u;
     unsigned int inputHeight    = 2u;
@@ -185,7 +205,7 @@
     int32_t inputOffset = 112;
     float inputScale    = 0.0125f;
 
-    return BoundedReLuTestCommon(workloadFactory, 1.0f, -1.0f,
+    return BoundedReLuTestCommon(workloadFactory, memoryManager, 1.0f, -1.0f,
                                  inputScale, inputOffset, inputScale, inputOffset, // Input/output scale & offset same.
                                  input, output,
                                  inputWidth, inputHeight, inputChannels, inputBatchSize);
@@ -219,10 +239,12 @@
     }
 };
 
-boost::multi_array<float, 4> BoundedReLuRandomInputTest(armnn::IWorkloadFactory& workloadFactory,
-                                                        float lowerBound,
-                                                        float upperBound,
-                                                        const armnn::ActivationDescriptor& activationDescriptor)
+boost::multi_array<float, 4> BoundedReLuRandomInputTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float lowerBound,
+    float upperBound,
+    const armnn::ActivationDescriptor& activationDescriptor)
 {
     const armnn::TensorInfo inputTensorInfo = BoundedReLuRandomInputTestTraits::GetInputTensorInfo();
     const armnn::TensorInfo outputTensorInfo = BoundedReLuRandomInputTestTraits::GetOutputTensorInfo();
@@ -259,10 +281,12 @@
 
 } // namespace
 
-LayerTestResult<float, 4> CompareBoundedReLuTest(armnn::IWorkloadFactory& workloadFactory,
-                                          armnn::IWorkloadFactory& otherWorkloadFactory,
-                                          float upperBound,
-                                          float lowerBound)
+LayerTestResult<float, 4> CompareBoundedReLuTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    float upperBound,
+    float lowerBound)
 {
     LayerTestResult<float, 4> result(BoundedReLuRandomInputTestTraits::GetOutputTensorInfo());
 
@@ -271,16 +295,20 @@
     activationDescriptor.m_A = upperBound;
     activationDescriptor.m_B = lowerBound;
 
-    result.output = BoundedReLuRandomInputTest(workloadFactory, 0.0f, upperBound, activationDescriptor);
-    result.outputExpected = BoundedReLuRandomInputTest(otherWorkloadFactory, 0.0f, upperBound, activationDescriptor);
+    result.output = BoundedReLuRandomInputTest(
+        workloadFactory, memoryManager, 0.0f, upperBound, activationDescriptor);
+    result.outputExpected = BoundedReLuRandomInputTest(
+        refWorkloadFactory, nullptr, 0.0f, upperBound, activationDescriptor);
 
     return result;
 }
 
 template<typename T>
-LayerTestResult<T,4> ConstantLinearActivationTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                        float qScale = 0.0f,
-                                                        int32_t qOffset = 0)
+LayerTestResult<T,4> ConstantLinearActivationTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 0.0f,
+    int32_t qOffset = 0)
 {
     unsigned int inputHeight    = 20;
     unsigned int inputWidth     = 17;
@@ -336,25 +364,31 @@
     return ret;
 }
 
-LayerTestResult<float, 4> ConstantLinearActivationTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> ConstantLinearActivationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return ConstantLinearActivationTestCommon<float>(workloadFactory);
+    return ConstantLinearActivationTestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> ConstantLinearActivationUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> ConstantLinearActivationUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return ConstantLinearActivationTestCommon<uint8_t>(workloadFactory, 4.0f, 3);
+    return ConstantLinearActivationTestCommon<uint8_t>(workloadFactory, memoryManager, 4.0f, 3);
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleActivationTest(armnn::IWorkloadFactory& workloadFactory,
-                                           armnn::ActivationFunction activationFunction,
-                                           float activationParameterA,
-                                           float activationParameterB,
-                                           float qScale,
-                                           int32_t qOffset,
-                                           const std::vector<float>& inputData,
-                                           const std::vector<float>& outputExpectedData)
+LayerTestResult<T, 4> SimpleActivationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::ActivationFunction activationFunction,
+    float activationParameterA,
+    float activationParameterB,
+    float qScale,
+    int32_t qOffset,
+    const std::vector<float>& inputData,
+    const std::vector<float>& outputExpectedData)
 {
     constexpr static unsigned int inputWidth = 16u;
     constexpr static unsigned int inputHeight = 1u;
@@ -415,7 +449,11 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleSigmoidTestCommon(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
+LayerTestResult<T, 4> SimpleSigmoidTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     std::vector<float> inputData = {
         -0.1f, -0.2f, -0.3f, -0.4f,
@@ -433,6 +471,7 @@
     std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
 
     return SimpleActivationTest<T>(workloadFactory,
+                                   memoryManager,
                                    armnn::ActivationFunction::Sigmoid,
                                    0.f,
                                    0.f,
@@ -442,23 +481,29 @@
                                    outputExpectedData);
 }
 
-LayerTestResult<float, 4> SimpleSigmoidTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SimpleSigmoidTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SimpleSigmoidTestCommon<float>(workloadFactory, 0.0f, 0);
+    return SimpleSigmoidTestCommon<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> SimpleSigmoidUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SimpleSigmoidUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SimpleSigmoidTestCommon<uint8_t>(workloadFactory, 0.1f, 50);
+    return SimpleSigmoidTestCommon<uint8_t>(workloadFactory, memoryManager, 0.1f, 50);
 }
 
 template<typename T>
-LayerTestResult<T,4> CompareActivationTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                               armnn::IWorkloadFactory& refWorkloadFactory,
-                                               armnn::ActivationFunction f,
-                                               unsigned int batchSize = 5,
-                                               float qScale = 0.0f,
-                                               int32_t qOffset = 0)
+LayerTestResult<T,4> CompareActivationTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::ActivationFunction f,
+    unsigned int batchSize = 5,
+    float qScale = 0.0f,
+    int32_t qOffset = 0)
 {
     unsigned int width     = 17;
     unsigned int height    = 29;
@@ -544,17 +589,23 @@
     return ret;
 }
 
-LayerTestResult<float,4> CompareActivationTest(armnn::IWorkloadFactory& workloadFactory,
-                                               armnn::IWorkloadFactory& refWorkloadFactory,
-                                               armnn::ActivationFunction f,
-                                               unsigned int batchSize)
+LayerTestResult<float,4> CompareActivationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::ActivationFunction f,
+    unsigned int batchSize)
 {
-    return CompareActivationTestImpl<float>(workloadFactory, refWorkloadFactory, f, batchSize);
+    return CompareActivationTestImpl<float>(
+        workloadFactory, memoryManager, refWorkloadFactory, f, batchSize);
 }
 
-LayerTestResult<uint8_t,4> CompareActivationUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                      armnn::IWorkloadFactory& refWorkloadFactory,
-                                                      armnn::ActivationFunction f)
+LayerTestResult<uint8_t,4> CompareActivationUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::ActivationFunction f)
 {
-    return CompareActivationTestImpl<uint8_t>(workloadFactory, refWorkloadFactory, f, 5, 0.1f, 50);
+    return CompareActivationTestImpl<uint8_t>(
+        workloadFactory, memoryManager, refWorkloadFactory, f, 5, 0.1f, 50);
 }
diff --git a/src/backends/backendsCommon/test/BatchNormTestImpl.hpp b/src/backends/backendsCommon/test/BatchNormTestImpl.hpp
index 67282ed..6325130 100644
--- a/src/backends/backendsCommon/test/BatchNormTestImpl.hpp
+++ b/src/backends/backendsCommon/test/BatchNormTestImpl.hpp
@@ -4,23 +4,28 @@
 //
 #pragma once
 
+#include "WorkloadTestUtils.hpp"
+
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 #include <backendsCommon/test/QuantizeHelper.hpp>
 
 #include <test/TensorHelpers.hpp>
 
 template<typename T>
-LayerTestResult<T, 4> BatchNormTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                        const armnn::TensorShape& inputOutputTensorShape,
-                                        const std::vector<float>& inputValues,
-                                        const std::vector<float>& expectedOutputValues,
-                                        float qScale,
-                                        int32_t qOffset,
-                                        armnn::DataLayout dataLayout)
+LayerTestResult<T, 4> BatchNormTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::TensorShape& inputOutputTensorShape,
+    const std::vector<float>& inputValues,
+    const std::vector<float>& expectedOutputValues,
+    float qScale,
+    int32_t qOffset,
+    armnn::DataLayout dataLayout)
 {
     armnn::TensorInfo inputTensorInfo(inputOutputTensorShape, armnn::GetDataType<T>());
     armnn::TensorInfo outputTensorInfo(inputOutputTensorShape, armnn::GetDataType<T>());
@@ -96,9 +101,11 @@
 
 
 template<typename T>
-LayerTestResult<T,4> BatchNormTestNhwcImpl(armnn::IWorkloadFactory& workloadFactory,
-                                           float qScale,
-                                           int32_t qOffset)
+LayerTestResult<T,4> BatchNormTestNhwcImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     const unsigned int width    = 2;
     const unsigned int height   = 3;
diff --git a/src/backends/backendsCommon/test/Conv2dTestImpl.hpp b/src/backends/backendsCommon/test/Conv2dTestImpl.hpp
index 03becab..d99b7f7 100755
--- a/src/backends/backendsCommon/test/Conv2dTestImpl.hpp
+++ b/src/backends/backendsCommon/test/Conv2dTestImpl.hpp
@@ -4,6 +4,8 @@
 //
 #pragma once
 
+#include "WorkloadTestUtils.hpp"
+
 #include <string>
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
@@ -13,6 +15,7 @@
 #include "QuantizeHelper.hpp"
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 #include "Permute.hpp"
 #include <boost/numeric/conversion/cast.hpp>
@@ -63,18 +66,20 @@
 }
 
 template<typename T, typename B>
-LayerTestResult<T, 4> SimpleConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                  const boost::multi_array<T, 4>& originalInput,
-                                                  const boost::multi_array<T, 4>& originalKernel,
-                                                  const boost::multi_array<B, 1>& bias,
-                                                  const boost::multi_array<T, 4>& originalOutputExpected,
-                                                  float qScale,
-                                                  int32_t qOffset,
-                                                  const armnn::DataLayoutIndexed& layout = armnn::DataLayout::NCHW,
-                                                  uint32_t padLeft = 0,
-                                                  uint32_t padTop = 0,
-                                                  uint32_t padRight = 0,
-                                                  uint32_t padBottom = 0)
+LayerTestResult<T, 4> SimpleConvolution2dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const boost::multi_array<T, 4>& originalInput,
+    const boost::multi_array<T, 4>& originalKernel,
+    const boost::multi_array<B, 1>& bias,
+    const boost::multi_array<T, 4>& originalOutputExpected,
+    float qScale,
+    int32_t qOffset,
+    const armnn::DataLayoutIndexed& layout = armnn::DataLayout::NCHW,
+    uint32_t padLeft = 0,
+    uint32_t padTop = 0,
+    uint32_t padRight = 0,
+    uint32_t padBottom = 0)
 {
     unsigned int inputHeight   = boost::numeric_cast<unsigned int>(originalInput.shape()[2]);
     unsigned int inputWidth    = boost::numeric_cast<unsigned int>(originalInput.shape()[3]);
@@ -213,9 +218,7 @@
 
     CopyDataToITensorHandle(inputHandle.get(), &batchedInput[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
 
@@ -223,20 +226,22 @@
 }
 
 template<typename T, typename B>
-LayerTestResult<T, 4> SimpleConvolution2dNhwcTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                      const boost::multi_array<T, 4>& input,
-                                                      const boost::multi_array<T, 4>& kernel,
-                                                      const boost::multi_array<B, 1>& bias,
-                                                      const boost::multi_array<T, 4>& outputExpected,
-                                                      armnn::DataLayout dataLayout,
-                                                      float qScale,
-                                                      int32_t qOffset,
-                                                      uint32_t padLeft = 1,
-                                                      uint32_t padTop = 1,
-                                                      uint32_t padRight = 1,
-                                                      uint32_t padBottom = 1,
-                                                      uint32_t strideX  = 1,
-                                                      uint32_t strideY  = 1)
+LayerTestResult<T, 4> SimpleConvolution2dNhwcTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const boost::multi_array<T, 4>& input,
+    const boost::multi_array<T, 4>& kernel,
+    const boost::multi_array<B, 1>& bias,
+    const boost::multi_array<T, 4>& outputExpected,
+    armnn::DataLayout dataLayout,
+    float qScale,
+    int32_t qOffset,
+    uint32_t padLeft = 1,
+    uint32_t padTop = 1,
+    uint32_t padRight = 1,
+    uint32_t padBottom = 1,
+    uint32_t strideX  = 1,
+    uint32_t strideY  = 1)
 {
     unsigned int inputNum       = boost::numeric_cast<unsigned int>(input.shape()[0]);
     unsigned int inputChannels  = boost::numeric_cast<unsigned int>(input.shape()[3]);
@@ -305,9 +310,7 @@
 
     CopyDataToITensorHandle(inputHandle.get(), &batchedInput[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
 
@@ -315,20 +318,22 @@
 }
 
 template<typename T, typename B>
-LayerTestResult<T, 4> DepthwiseConvolution2dAsymmetricTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                               const boost::multi_array<T, 4>& input,
-                                                               const boost::multi_array<T, 4>& originalKernel,
-                                                               const boost::multi_array<B, 1>& bias,
-                                                               const boost::multi_array<T, 4>& outputExpected,
-                                                               float qScale,
-                                                               int32_t qOffset,
-                                                               const armnn::DataLayoutIndexed& layout,
-                                                               uint32_t padLeft = 0,
-                                                               uint32_t padTop = 0,
-                                                               uint32_t padRight = 0,
-                                                               uint32_t padBottom = 0,
-                                                               uint32_t strideX = 1,
-                                                               uint32_t strideY = 1)
+LayerTestResult<T, 4> DepthwiseConvolution2dAsymmetricTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const boost::multi_array<T, 4>& input,
+    const boost::multi_array<T, 4>& originalKernel,
+    const boost::multi_array<B, 1>& bias,
+    const boost::multi_array<T, 4>& outputExpected,
+    float qScale,
+    int32_t qOffset,
+    const armnn::DataLayoutIndexed& layout,
+    uint32_t padLeft = 0,
+    uint32_t padTop = 0,
+    uint32_t padRight = 0,
+    uint32_t padBottom = 0,
+    uint32_t strideX = 1,
+    uint32_t strideY = 1)
 {
     unsigned int inputNum       = boost::numeric_cast<unsigned int>(input.shape()[0]);
     unsigned int inputChannels  = boost::numeric_cast<unsigned int>(input.shape()[1]);
@@ -455,11 +460,13 @@
 }
 
 template<typename T, typename B>
-LayerTestResult<T, 4> DepthwiseConvolution2dDepthMul1TestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                              float qScale,
-                                                              int32_t qOffset,
-                                                              bool biasEnabled,
-                                                              const armnn::DataLayoutIndexed& layout)
+LayerTestResult<T, 4> DepthwiseConvolution2dDepthMul1TestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
     unsigned int inputHeight = 3;
     unsigned int inputWidth = 3;
@@ -598,11 +605,13 @@
 }
 
 template<typename T, typename B>
-LayerTestResult<T, 4> DepthwiseConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                     float qScale,
-                                                     int32_t qOffset,
-                                                     bool biasEnabled,
-                                                     const armnn::DataLayoutIndexed& layout)
+LayerTestResult<T, 4> DepthwiseConvolution2dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
     unsigned int depthMultiplier = 2;
 
@@ -799,19 +808,21 @@
 }
 
 template<typename T, typename B>
-LayerTestResult<T, 4> DepthwiseConvolution2dNhwcTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                         const boost::multi_array<T, 4>& input,
-                                                         const boost::multi_array<T, 4>& kernel,
-                                                         const boost::multi_array<B, 1>& bias,
-                                                         const boost::multi_array<T, 4>& outputExpected,
-                                                         float qScale,
-                                                         int32_t qOffset,
-                                                         uint32_t padLeft = 0,
-                                                         uint32_t padTop = 0,
-                                                         uint32_t padRight = 0,
-                                                         uint32_t padBottom = 0,
-                                                         uint32_t strideX = 1,
-                                                         uint32_t strideY = 1)
+LayerTestResult<T, 4> DepthwiseConvolution2dNhwcTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const boost::multi_array<T, 4>& input,
+    const boost::multi_array<T, 4>& kernel,
+    const boost::multi_array<B, 1>& bias,
+    const boost::multi_array<T, 4>& outputExpected,
+    float qScale,
+    int32_t qOffset,
+    uint32_t padLeft = 0,
+    uint32_t padTop = 0,
+    uint32_t padRight = 0,
+    uint32_t padBottom = 0,
+    uint32_t strideX = 1,
+    uint32_t strideY = 1)
 {
     unsigned int inputNum       = boost::numeric_cast<unsigned int>(input.shape()[0]);
     unsigned int inputChannels  = boost::numeric_cast<unsigned int>(input.shape()[3]);
@@ -898,10 +909,12 @@
 }
 
 template<typename T>
-LayerTestResult<T,4> Convolution1dTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                           float qScale,
-                                           int32_t qOffset,
-                                           bool biasEnabled)
+LayerTestResult<T,4> Convolution1dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled)
 {
     using B = typename FullyConnectedBiasTypeForInputType<T>::Type;
 
@@ -1005,9 +1018,7 @@
 
     CopyDataToITensorHandle(inputHandle.get(), inputData.data());
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     // Output
     LayerTestResult<T,4> ret(outputInfo);
@@ -1019,8 +1030,10 @@
 
 
 template<typename T>
-LayerTestResult<T,4> CompareConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                armnn::IWorkloadFactory& refWorkloadFactory)
+LayerTestResult<T,4> CompareConvolution2dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory)
 {
     unsigned int inputHeight   = 8;
     unsigned int inputWidth    = 16;
@@ -1104,9 +1117,7 @@
     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
     CopyDataToITensorHandle(inputHandleRef.get(), &input[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     workloadRef->Execute();
 
@@ -1117,9 +1128,11 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> CompareDepthwiseConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                            armnn::IWorkloadFactory& refWorkloadFactory,
-                                                            const armnn::DataLayoutIndexed& layout)
+LayerTestResult<T, 4> CompareDepthwiseConvolution2dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    const armnn::DataLayoutIndexed& layout)
 {
     unsigned int inputHeight = 8;
     unsigned int inputWidth = 16;
@@ -1229,6 +1242,7 @@
     CopyDataToITensorHandle(inputHandleRef.get(), &input[0][0][0][0]);
 
     workload->Execute();
+
     workloadRef->Execute();
 
     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
diff --git a/src/backends/backendsCommon/test/ConvertFp16ToFp32TestImpl.hpp b/src/backends/backendsCommon/test/ConvertFp16ToFp32TestImpl.hpp
index a63f0cb..1a86f4c 100644
--- a/src/backends/backendsCommon/test/ConvertFp16ToFp32TestImpl.hpp
+++ b/src/backends/backendsCommon/test/ConvertFp16ToFp32TestImpl.hpp
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "WorkloadTestUtils.hpp"
+
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
 #include <armnn/TypesUtils.hpp>
@@ -12,10 +14,13 @@
 #include <Half.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 
 #include <test/TensorHelpers.hpp>
 
-LayerTestResult<float, 4> SimpleConvertFp16ToFp32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SimpleConvertFp16ToFp32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     using namespace half_float::literal;
 
diff --git a/src/backends/backendsCommon/test/ConvertFp32ToFp16TestImpl.hpp b/src/backends/backendsCommon/test/ConvertFp32ToFp16TestImpl.hpp
index 3513823..46176e1 100644
--- a/src/backends/backendsCommon/test/ConvertFp32ToFp16TestImpl.hpp
+++ b/src/backends/backendsCommon/test/ConvertFp32ToFp16TestImpl.hpp
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "WorkloadTestUtils.hpp"
+
 #include <Half.hpp>
 
 #include <armnn/ArmNN.hpp>
@@ -12,11 +14,14 @@
 #include <armnn/TypesUtils.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 
 #include <test/TensorHelpers.hpp>
 
 
-LayerTestResult<armnn::Half, 4> SimpleConvertFp32ToFp16Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<armnn::Half, 4> SimpleConvertFp32ToFp16Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     using namespace half_float::literal;
 
diff --git a/src/backends/backendsCommon/test/FullyConnectedTestImpl.hpp b/src/backends/backendsCommon/test/FullyConnectedTestImpl.hpp
index 298901e..e7c0f01 100644
--- a/src/backends/backendsCommon/test/FullyConnectedTestImpl.hpp
+++ b/src/backends/backendsCommon/test/FullyConnectedTestImpl.hpp
@@ -3,9 +3,14 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "WorkloadTestUtils.hpp"
+
+#include <backendsCommon/IBackendInternal.hpp>
+
 template<typename T, typename B>
 LayerTestResult<T, 2> SimpleFullyConnectedTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::TensorInfo inputTensorInfo,
     armnn::TensorInfo outputTensorInfo,
     armnn::TensorInfo weightsDesc,
@@ -41,16 +46,17 @@
     outputHandle->Allocate();
     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
 
     return result;
 }
 
-LayerTestResult<float, 2> FullyConnectedFloat32Test(armnn::IWorkloadFactory& workloadFactory, bool biasEnabled,
+LayerTestResult<float, 2> FullyConnectedFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
     bool transposeWeights)
 {
     unsigned int inputWidth = 1;
@@ -120,6 +126,7 @@
 
     result = SimpleFullyConnectedTestImpl<float>(
         workloadFactory,
+        memoryManager,
         inputTensorInfo, outputTensorInfo,
         weightsDesc, biasesDesc,
         weights, bias, input,
@@ -141,7 +148,10 @@
     return result;
 }
 
-LayerTestResult<uint8_t, 2> FullyConnectedUint8Test(armnn::IWorkloadFactory& workloadFactory, bool biasEnabled)
+LayerTestResult<uint8_t, 2> FullyConnectedUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled)
 {
     constexpr static unsigned int inputWidth = 3u;
     constexpr static unsigned int inputHeight = 2u;
@@ -181,6 +191,7 @@
 
     result = SimpleFullyConnectedTestImpl<uint8_t>(
         workloadFactory,
+        memoryManager,
         inputTensorInfo, outputTensorInfo,
         weightsDesc, biasesDesc,
         weights, bias, input,
@@ -210,10 +221,12 @@
 // Note this is templated for consistency, but the nature of this tests makes it unlikely to be useful in Uint8 mode.
 //
 template<typename T>
-LayerTestResult<T, 2> FullyConnectedLargeTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                        bool transposeWeights,
-                                                        float qScale = 0.0f,
-                                                        int32_t qOffset = 0)
+LayerTestResult<T, 2> FullyConnectedLargeTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool transposeWeights,
+    float qScale = 0.0f,
+    int32_t qOffset = 0)
 {
     unsigned int inputWidth = 1;
     unsigned int inputHeight = 1;
@@ -272,6 +285,7 @@
 
     result = SimpleFullyConnectedTestImpl<T>(
         workloadFactory,
+        memoryManager,
         inputTensorInfo, outputTensorInfo,
         weightsDesc, biasesDesc,
         weights, bias, input,
diff --git a/src/backends/backendsCommon/test/LayerTests.cpp b/src/backends/backendsCommon/test/LayerTests.cpp
index 1ce6914..dad1341 100755
--- a/src/backends/backendsCommon/test/LayerTests.cpp
+++ b/src/backends/backendsCommon/test/LayerTests.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 #include "LayerTests.hpp"
+#include "WorkloadTestUtils.hpp"
 
 #include "test/TensorHelpers.hpp"
 #include "TensorCopyUtils.hpp"
@@ -14,6 +15,7 @@
 #include <armnn/LayerSupport.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
 #include <algorithm>
@@ -101,11 +103,13 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleConvolution2d3x5TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                       float                    qScale,
-                                                       int32_t                  qOffset,
-                                                       bool                     biasEnabled,
-                                                       const armnn::DataLayoutIndexed& layout)
+LayerTestResult<T, 4> SimpleConvolution2d3x5TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
     // Use common single-batch 3-channel 16x8 image.
     armnn::TensorInfo inputDesc({1, 3, 8, 16}, armnn::GetDataType<T>());
@@ -171,6 +175,7 @@
         })));
 
     return SimpleConvolution2dTestImpl<T>(workloadFactory,
+      memoryManager,
       input,
       kernel,
       GetBias2<typename FullyConnectedBiasTypeForInputType<T>::Type>(biasEnabled, qScale, qOffset),
@@ -181,11 +186,13 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleConvolution2d3x3TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                       float                    qScale,
-                                                       int32_t                  qOffset,
-                                                       bool                     biasEnabled,
-                                                       const armnn::DataLayoutIndexed& layout)
+LayerTestResult<T, 4> SimpleConvolution2d3x3TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
     // Use a 3x3 kernel, which exercises ArmCompute's direct convolution path.
 
@@ -243,6 +250,7 @@
         })));
 
     return SimpleConvolution2dTestImpl<T>(workloadFactory,
+      memoryManager,
       input,
       kernel,
       GetBias2<typename FullyConnectedBiasTypeForInputType<T>::Type>(biasEnabled, qScale, qOffset),
@@ -253,11 +261,13 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleConvolution2d3x3NhwcTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                           float                    qScale,
-                                                           int32_t                  qOffset,
-                                                           bool                     biasEnabled,
-                                                           armnn::DataLayout        dataLayout)
+LayerTestResult<T, 4> SimpleConvolution2d3x3NhwcTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled,
+    armnn::DataLayout dataLayout)
 {
     // Use common single-batch 5x5 image.
 
@@ -291,6 +301,7 @@
     boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputDesc, outputData);
 
     return SimpleConvolution2dNhwcTestImpl<T>(workloadFactory,
+                                              memoryManager,
                                               input,
                                               kernel,
                                               boost::multi_array<T, 1>(),
@@ -300,46 +311,62 @@
                                               qOffset);
 }
 
-LayerTestResult<float, 4> SimpleConvolution2d3x5Test(armnn::IWorkloadFactory& workloadFactory,
-                                                     bool                     biasEnabled,
-                                                     const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> SimpleConvolution2d3x5Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return SimpleConvolution2d3x5TestCommon<float>(workloadFactory, 0.f, 0, biasEnabled, layout);
+    return SimpleConvolution2d3x5TestCommon<float>(workloadFactory, memoryManager, 0.f, 0, biasEnabled, layout);
 }
 
-LayerTestResult<uint8_t, 4> SimpleConvolution2d3x5Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            bool                     biasEnabled,
-                                                            const armnn::DataLayoutIndexed& layout)
+LayerTestResult<uint8_t, 4> SimpleConvolution2d3x5Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return SimpleConvolution2d3x5TestCommon<uint8_t>(workloadFactory, 0.5f, 50, biasEnabled, layout);
+    return SimpleConvolution2d3x5TestCommon<uint8_t>(workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
 }
 
-LayerTestResult<float, 4> SimpleConvolution2d3x3Test(armnn::IWorkloadFactory& workloadFactory,
-                                                     bool                     biasEnabled,
-                                                     const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> SimpleConvolution2d3x3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return SimpleConvolution2d3x3TestCommon<float>(workloadFactory, 0.f, 0, biasEnabled, layout);
+    return SimpleConvolution2d3x3TestCommon<float>(workloadFactory, memoryManager, 0.f, 0, biasEnabled, layout);
 }
 
-LayerTestResult<float, 4> SimpleConvolution2d3x3NhwcTest(armnn::IWorkloadFactory& workloadFactory,
-                                                         bool                     biasEnabled)
+LayerTestResult<float, 4> SimpleConvolution2d3x3NhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled)
 {
-    return SimpleConvolution2d3x3NhwcTestCommon<float>(workloadFactory, 0.f, 0, biasEnabled, armnn::DataLayout::NHWC);
+    return SimpleConvolution2d3x3NhwcTestCommon<float>(workloadFactory,
+                                                       memoryManager,
+                                                       0.f,
+                                                       0,
+                                                       biasEnabled,
+                                                       armnn::DataLayout::NHWC);
 }
 
-LayerTestResult<uint8_t, 4> SimpleConvolution2d3x3Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            bool                     biasEnabled,
-                                                            const armnn::DataLayoutIndexed& layout)
+LayerTestResult<uint8_t, 4> SimpleConvolution2d3x3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return SimpleConvolution2d3x3TestCommon<uint8_t>(workloadFactory, 0.5f, 50, biasEnabled, layout);
+    return SimpleConvolution2d3x3TestCommon<uint8_t>(workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
 }
 
 template<typename T>
 LayerTestResult<T, 4> Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTestCommon(
     armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::DataLayoutIndexed& layout,
-    float                    qScale,
-    int32_t                  qOffset)
+    float qScale,
+    int32_t qOffset)
 {
     // Use a single-batch 1-channel 3x3 image as input.
     armnn::TensorInfo inputDesc({1, 1, 3, 3}, armnn::GetDataType<T>());
@@ -381,6 +408,7 @@
         })));
 
     return SimpleConvolution2dTestImpl<T>(workloadFactory,
+      memoryManager,
       input,
       kernel,
       GetBias2<typename FullyConnectedBiasTypeForInputType<T>::Type>(false, qScale, qOffset),
@@ -395,10 +423,12 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleConvolution2dAsymmetricPaddingTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                                     const armnn::DataLayoutIndexed& layout,
-                                                                     float qScale,
-                                                                     int32_t qOffset)
+LayerTestResult<T, 4> SimpleConvolution2dAsymmetricPaddingTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout,
+    float qScale,
+    int32_t qOffset)
 {
     // Use a single-batch 1-channel 5x5 image as input.
     armnn::TensorInfo inputDesc({ 1, 1, 5, 5 }, armnn::GetDataType<T>());
@@ -434,6 +464,7 @@
         })));
 
     return SimpleConvolution2dTestImpl<T>(workloadFactory,
+        memoryManager,
         input,
         kernel,
         GetBias2<typename FullyConnectedBiasTypeForInputType<T>::Type>(false, qScale, qOffset),
@@ -448,11 +479,13 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> DepthwiseConvolution2dAsymmetricTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                                 float qScale,
-                                                                 int32_t qOffset,
-                                                                 bool biasEnabled,
-                                                                 const armnn::DataLayoutIndexed& layout)
+LayerTestResult<T, 4> DepthwiseConvolution2dAsymmetricTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
     // Use a single-batch 2-channel 5x5 image as input.
     armnn::TensorInfo inputTensorInfo({ 1, 2, 5, 5 }, armnn::GetDataType<T>());
@@ -504,6 +537,7 @@
         })));
 
     return DepthwiseConvolution2dAsymmetricTestImpl<T>(workloadFactory,
+        memoryManager,
         input,
         kernel,
         GetBias2<typename FullyConnectedBiasTypeForInputType<T>::Type>(biasEnabled, qScale, qOffset),
@@ -520,10 +554,12 @@
 }
 
 template<typename T>
-LayerTestResult<T, 4> DepthwiseConvolution2dNhwcTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                           float qScale,
-                                                           int32_t qOffset,
-                                                           bool biasEnabled)
+LayerTestResult<T, 4> DepthwiseConvolution2dNhwcTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset,
+    bool biasEnabled)
 {
     armnn::TensorInfo inputTensorInfo({ 1, 5, 5, 2}, armnn::GetDataType<T>());
     auto input = MakeTensor<T, 4>(inputTensorInfo, std::vector<T>(
@@ -618,6 +654,7 @@
         })));
 
     return DepthwiseConvolution2dNhwcTestImpl<T>(workloadFactory,
+        memoryManager,
         input,
         kernel,
         GetBias2<typename FullyConnectedBiasTypeForInputType<T>::Type>(biasEnabled, qScale, qOffset),
@@ -633,163 +670,230 @@
 }
 
 LayerTestResult<float, 4>
-Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest(armnn::IWorkloadFactory& workloadFactory,
-                                                           const armnn::DataLayoutIndexed& layout)
+Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTestCommon<float>(workloadFactory, layout, 0.0f, 0);
+    return Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTestCommon<float>(
+         workloadFactory, memoryManager, layout, 0.0f, 0);
 }
 
-LayerTestResult<float, 4> Convolution2dAsymmetricPaddingTest(armnn::IWorkloadFactory& workloadFactory,
-                                                             const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> Convolution2dAsymmetricPaddingTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return SimpleConvolution2dAsymmetricPaddingTestCommon<float>(workloadFactory, layout, 0.0f, 0);
+    return SimpleConvolution2dAsymmetricPaddingTestCommon<float>(
+        workloadFactory, memoryManager, layout, 0.0f, 0);
 }
 
-LayerTestResult<float, 4> DepthwiseConvolution2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                     bool                     biasEnabled,
-                                                     const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> DepthwiseConvolution2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return DepthwiseConvolution2dTestImpl<float, float>(workloadFactory, 0.0f, 0, biasEnabled, layout);
+    return DepthwiseConvolution2dTestImpl<float, float>(
+        workloadFactory, memoryManager, 0.0f, 0, biasEnabled, layout);
 }
 
-LayerTestResult<float, 4> DepthwiseConvolution2dDepthNhwcTest(armnn::IWorkloadFactory& workloadFactory,
-                                                              bool biasEnabled)
+LayerTestResult<float, 4> DepthwiseConvolution2dDepthNhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled)
 {
-    return DepthwiseConvolution2dNhwcTestCommon<float>(workloadFactory, 0.0f, 0, biasEnabled);
+    return DepthwiseConvolution2dNhwcTestCommon<float>(workloadFactory, memoryManager, 0.0f, 0, biasEnabled);
 }
 
-LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul1Test(armnn::IWorkloadFactory& workloadFactory,
-                                                              bool biasEnabled,
-                                                              const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return DepthwiseConvolution2dDepthMul1TestImpl<float, float>(workloadFactory, 0.0f, 0, biasEnabled, layout);
+    return DepthwiseConvolution2dDepthMul1TestImpl<float, float>(
+        workloadFactory, memoryManager, 0.0f, 0, biasEnabled, layout);
 }
 
-LayerTestResult<float, 4> DepthwiseConvolution2dAsymmetricTest(armnn::IWorkloadFactory& workloadFactory,
-                                                               bool biasEnabled,
-                                                               const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> DepthwiseConvolution2dAsymmetricTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return DepthwiseConvolution2dAsymmetricTestCommon<float>(workloadFactory, 0.0f, 0, biasEnabled, layout);
+    return DepthwiseConvolution2dAsymmetricTestCommon<float>(
+        workloadFactory, memoryManager, 0.0f, 0, biasEnabled, layout);
 }
 
-LayerTestResult<uint8_t, 4> DepthwiseConvolution2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            bool                     biasEnabled,
-                                                            const armnn::DataLayoutIndexed& layout)
+LayerTestResult<uint8_t, 4> DepthwiseConvolution2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return DepthwiseConvolution2dTestImpl<uint8_t, int32_t>(workloadFactory, 0.5f, 50, biasEnabled, layout);
+    return DepthwiseConvolution2dTestImpl<uint8_t, int32_t>(
+        workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
 }
 
-LayerTestResult<uint8_t, 4> DepthwiseConvolution2dDepthMul1Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                     bool biasEnabled,
-                                                                     const armnn::DataLayoutIndexed& layout)
+LayerTestResult<uint8_t, 4> DepthwiseConvolution2dDepthMul1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return DepthwiseConvolution2dDepthMul1TestImpl<uint8_t, int32_t>(workloadFactory, 0.5f, 50, biasEnabled, layout);
+    return DepthwiseConvolution2dDepthMul1TestImpl<uint8_t, int32_t>(
+        workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
 }
 
-LayerTestResult<float, 4> Convolution1dTest(armnn::IWorkloadFactory& workloadFactory, bool biasEnabled)
+LayerTestResult<float, 4> Convolution1dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled)
 {
-    return Convolution1dTestImpl<float>(workloadFactory, 0.0f, 0, biasEnabled);
+    return Convolution1dTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0, biasEnabled);
 }
 
-LayerTestResult<uint8_t, 4> Convolution1dUint8Test(armnn::IWorkloadFactory& workloadFactory, bool biasEnabled)
+LayerTestResult<uint8_t, 4> Convolution1dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled)
 {
-    return Convolution1dTestImpl<uint8_t>(workloadFactory, 0.1f, 128, biasEnabled);
+    return Convolution1dTestImpl<uint8_t>(workloadFactory, memoryManager, 0.1f, 128, biasEnabled);
 }
 
-LayerTestResult<float,4> CompareConvolution2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                  armnn::IWorkloadFactory& refWorkloadFactory)
+LayerTestResult<float,4> CompareConvolution2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory)
 {
-    return CompareConvolution2dTestImpl<float>(workloadFactory, refWorkloadFactory);
+    return CompareConvolution2dTestImpl<float>(workloadFactory, memoryManager, refWorkloadFactory);
 }
 
 template<typename T>
-LayerTestResult<T,4> CompareDepthwiseConvolution2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                       armnn::IWorkloadFactory& refWorkloadFactory,
-                                                       const armnn::DataLayoutIndexed& layout)
+LayerTestResult<T,4> CompareDepthwiseConvolution2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    const armnn::DataLayoutIndexed& layout)
 {
-    return CompareDepthwiseConvolution2dTestImpl<T>(workloadFactory, refWorkloadFactory, layout);
+    return CompareDepthwiseConvolution2dTestImpl<T>(workloadFactory, memoryManager, refWorkloadFactory, layout);
 }
 
 template LayerTestResult<float, 4> CompareDepthwiseConvolution2dTest<float>(
-    armnn::IWorkloadFactory&, armnn::IWorkloadFactory&, const armnn::DataLayoutIndexed&);
-template LayerTestResult<uint8_t, 4> CompareDepthwiseConvolution2dTest<uint8_t>(
-    armnn::IWorkloadFactory&, armnn::IWorkloadFactory&, const armnn::DataLayoutIndexed&);
+    armnn::IWorkloadFactory&,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
+    armnn::IWorkloadFactory&,
+    const armnn::DataLayoutIndexed&);
 
-LayerTestResult<float,4> SimpleNormalizationAcrossTest(armnn::IWorkloadFactory& workloadFactory)
+template LayerTestResult<uint8_t, 4> CompareDepthwiseConvolution2dTest<uint8_t>(
+    armnn::IWorkloadFactory&,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
+    armnn::IWorkloadFactory&,
+    const armnn::DataLayoutIndexed&);
+
+LayerTestResult<float,4> SimpleNormalizationAcrossTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     auto normMethod = armnn::NormalizationAlgorithmMethod::LocalBrightness;
     auto normChannel = armnn::NormalizationAlgorithmChannel::Across;
-    return SimpleNormalizationTestImpl(workloadFactory, normChannel, normMethod);
+    return SimpleNormalizationTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
 }
 
-LayerTestResult<float,4> SimpleNormalizationWithinTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float,4> SimpleNormalizationWithinTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     auto normMethod = armnn::NormalizationAlgorithmMethod::LocalBrightness;
     auto normChannel = armnn::NormalizationAlgorithmChannel::Within;
-    return SimpleNormalizationTestImpl(workloadFactory, normChannel, normMethod);
+    return SimpleNormalizationTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
 }
 
-LayerTestResult<float,4> SimpleNormalizationAcrossNhwcTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float,4> SimpleNormalizationAcrossNhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     auto normMethod = armnn::NormalizationAlgorithmMethod::LocalBrightness;
     auto normChannel = armnn::NormalizationAlgorithmChannel::Across;
-    return SimpleNormalizationNhwcTestImpl(workloadFactory, normChannel, normMethod);
+    return SimpleNormalizationNhwcTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
 }
 
-LayerTestResult<float,2> SimpleSoftmaxTest(armnn::IWorkloadFactory& workloadFactory, float beta)
+LayerTestResult<float,2> SimpleSoftmaxTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float beta)
 {
-    return SimpleSoftmaxTestImpl<float>(workloadFactory, beta);
+    return SimpleSoftmaxTestImpl<float>(workloadFactory, memoryManager, beta);
 }
 
-LayerTestResult<uint8_t,2> SimpleSoftmaxUint8Test(armnn::IWorkloadFactory& workloadFactory, float beta)
+LayerTestResult<uint8_t,2> SimpleSoftmaxUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float beta)
 {
-    return SimpleSoftmaxTestImpl<uint8_t>(workloadFactory, beta);
+    return SimpleSoftmaxTestImpl<uint8_t>(workloadFactory, memoryManager, beta);
 }
 
-LayerTestResult<float,4> CompareNormalizationTest(armnn::IWorkloadFactory& workloadFactory,
-                                                  armnn::IWorkloadFactory& refWorkloadFactory,
-                                                  armnn::NormalizationAlgorithmChannel normChannel,
-                                                  armnn::NormalizationAlgorithmMethod normMethod)
+LayerTestResult<float,4> CompareNormalizationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::NormalizationAlgorithmChannel normChannel,
+    armnn::NormalizationAlgorithmMethod normMethod)
 {
-    return CompareNormalizationTestImpl(workloadFactory, refWorkloadFactory, normChannel, normMethod);
+    return CompareNormalizationTestImpl(workloadFactory, memoryManager, refWorkloadFactory, normChannel, normMethod);
 }
 
-LayerTestResult<float,2> CompareSoftmaxTest(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<float,2> CompareSoftmaxTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::IWorkloadFactory& refWorkloadFactory,
     float beta)
 {
-    return CompareSoftmaxTestImpl<float>(workloadFactory, refWorkloadFactory, beta);
+    return CompareSoftmaxTestImpl<float>(workloadFactory, memoryManager, refWorkloadFactory, beta);
 }
 
-LayerTestResult<uint8_t,2> CompareSoftmaxUint8Test(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<uint8_t,2> CompareSoftmaxUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::IWorkloadFactory& refWorkloadFactory,
     float beta)
 {
-    return CompareSoftmaxTestImpl<uint8_t>(workloadFactory, refWorkloadFactory, beta);
+    return CompareSoftmaxTestImpl<uint8_t>(workloadFactory, memoryManager, refWorkloadFactory, beta);
 }
 
-std::vector<LayerTestResult<float,3>> SplitterTest(armnn::IWorkloadFactory& workloadFactory)
+std::vector<LayerTestResult<float,3>> SplitterTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SplitterTestCommon<float>(workloadFactory);
+    return SplitterTestCommon<float>(workloadFactory, memoryManager);
 }
 
-std::vector<LayerTestResult<uint8_t,3>> SplitterUint8Test(armnn::IWorkloadFactory& workloadFactory)
+std::vector<LayerTestResult<uint8_t,3>> SplitterUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SplitterTestCommon<uint8_t>(workloadFactory, 1.0f, 0);
+    return SplitterTestCommon<uint8_t>(workloadFactory, memoryManager, 1.0f, 0);
 }
 
-LayerTestResult<float, 3> CopyViaSplitterTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> CopyViaSplitterTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return CopyViaSplitterTestImpl<float>(workloadFactory, 0.0f, 0);
+    return CopyViaSplitterTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<uint8_t, 3> CopyViaSplitterUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> CopyViaSplitterUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return CopyViaSplitterTestImpl<uint8_t>(workloadFactory, 1.0f, 0);
+    return CopyViaSplitterTestImpl<uint8_t>(workloadFactory, memoryManager, 1.0f, 0);
 }
 
 LayerTestResult<float, 2> LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest(
-        armnn::IWorkloadFactory& workloadFactory)
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputDesc({ 2, 2 }, armnn::GetDataType<float>());
     boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
@@ -799,11 +903,13 @@
     boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(outputDesc, std::vector<float>(
             {-0.36444446f, -0.00352185f, 0.12886585f, -0.05163646f,
              -0.42734814f, -0.00478661f,  0.13455015f, -0.03560682f}));
-    return LstmLayerWithCifgWithPeepholeNoProjectionTestImpl(workloadFactory, input, expectedOutput);
+    return LstmLayerWithCifgWithPeepholeNoProjectionTestImpl(
+        workloadFactory, memoryManager, input, expectedOutput);
 }
 
 LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest(
-        armnn::IWorkloadFactory& workloadFactory)
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputDesc({ 2, 5 }, armnn::GetDataType<float>());
     boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
@@ -819,10 +925,13 @@
              -0.0186926f,   0.0193662f,   -0.0115437f,  0.00422612f,  -0.0345232f,
              0.00223253f,   -0.00957321f, 0.0210624f,   0.013331f,    0.0150954f,
              0.02168f}));
-    return LstmLayerFloat32NoCifgWithPeepholeWithProjectionTestImpl(workloadFactory, input, expectedOutput);
+    return LstmLayerFloat32NoCifgWithPeepholeWithProjectionTestImpl(
+        workloadFactory, memoryManager, input, expectedOutput);
 }
 
-LayerTestResult<float, 2> LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 2> LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputDesc({2, 2}, armnn::GetDataType<float>());
     boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
@@ -834,10 +943,13 @@
             {{-0.02973187f, 0.1229473f,   0.20885126f, -0.15358765f,
               -0.0185422f,   0.11281417f,  0.24466537f, -0.1826292f}}));
 
-    return LstmNoCifgNoPeepholeNoProjectionTestImpl(workloadFactory, input, expectedOutput);
+    return LstmNoCifgNoPeepholeNoProjectionTestImpl(
+        workloadFactory, memoryManager, input, expectedOutput);
 }
 
-LayerTestResult<float,3> MergerTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float,3> MergerTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int outputWidth = 3;
     unsigned int outputHeight = 6;
@@ -957,7 +1069,9 @@
     return ret;
 }
 
-LayerTestResult<float,4> AdditionTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float,4> AdditionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int batchSize = 2;
     unsigned int channels  = 2;
@@ -1047,7 +1161,9 @@
 }
 
 template <typename T>
-LayerTestResult<T, 4> AdditionBroadcastTestImpl(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<T, 4> AdditionBroadcastTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     float qScale,
     int32_t qOffset)
 {
@@ -1123,7 +1239,9 @@
 }
 
 template <typename T>
-LayerTestResult<T, 4> AdditionBroadcast1ElementTestImpl(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<T, 4> AdditionBroadcast1ElementTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     float qScale,
     int32_t qOffset)
 {
@@ -1193,28 +1311,38 @@
     return ret;
 }
 
-LayerTestResult<float, 4> AdditionBroadcastTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> AdditionBroadcastTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return AdditionBroadcastTestImpl<float>(workloadFactory, 0.0f, 0);
+    return AdditionBroadcastTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> AdditionBroadcastUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> AdditionBroadcastUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return AdditionBroadcastTestImpl<uint8_t>(workloadFactory, 2.f, 0);
+    return AdditionBroadcastTestImpl<uint8_t>(workloadFactory, memoryManager, 2.f, 0);
 }
 
-LayerTestResult<float, 4> AdditionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> AdditionBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return AdditionBroadcast1ElementTestImpl<float>(workloadFactory, 0.0f, 0);
+    return AdditionBroadcast1ElementTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> AdditionBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> AdditionBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return AdditionBroadcast1ElementTestImpl<uint8_t>(workloadFactory, 0.1333333f, 128);
+    return AdditionBroadcast1ElementTestImpl<uint8_t>(workloadFactory, memoryManager, 0.1333333f, 128);
 }
 
-LayerTestResult<float,4> CompareAdditionTest(armnn::IWorkloadFactory& workloadFactory,
-                                             armnn::IWorkloadFactory& refWorkloadFactory)
+LayerTestResult<float,4> CompareAdditionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory)
 {
     unsigned int batchSize = 4;
     unsigned int channels  = 1;
@@ -1281,19 +1409,21 @@
 
 namespace {
 template <typename T>
-LayerTestResult<T, 4> DivisionTestHelper(armnn::IWorkloadFactory& workloadFactory,
-                                         const unsigned int shape0[4],
-                                         const std::vector<T>& values0,
-                                         float scale0,
-                                         int32_t offset0,
-                                         const unsigned int shape1[4],
-                                         const std::vector<T> & values1,
-                                         float scale1,
-                                         int32_t offset1,
-                                         const unsigned int outShape[4],
-                                         const std::vector<T> & outValues,
-                                         float outScale,
-                                         int32_t outOffset)
+LayerTestResult<T, 4> DivisionTestHelper(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const unsigned int shape0[4],
+    const std::vector<T>& values0,
+    float scale0,
+    int32_t offset0,
+    const unsigned int shape1[4],
+    const std::vector<T> & values1,
+    float scale1,
+    int32_t offset1,
+    const unsigned int outShape[4],
+    const std::vector<T> & outValues,
+    float outScale,
+    int32_t outOffset)
 {
     auto dataType = (std::is_same<T, uint8_t>::value ?
                      armnn::DataType::QuantisedAsymm8 :
@@ -1345,7 +1475,9 @@
 }
 } // anonymous namespace
 
-LayerTestResult<float,4> DivisionByZeroTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float,4> DivisionByZeroTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int width = 2;
     const unsigned int height = 2;
@@ -1367,12 +1499,15 @@
                                -INFINITY, -INFINITY, INFINITY, INFINITY,  1, 1, 1, 1 });
 
     return DivisionTestHelper<float>(workloadFactory,
+                                     memoryManager,
                                      shape, input0, 1.0f, 0,
                                      shape, input1, 1.0f, 0,
                                      shape, output, 1.0f, 0);
 }
 
-LayerTestResult<float,4> DivisionTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float,4> DivisionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int width = 2;
     const unsigned int height = 2;
@@ -1395,12 +1530,15 @@
 
 
     return DivisionTestHelper<float>(workloadFactory,
+                                     memoryManager,
                                      shape, input0, 1.0f, 0,
                                      shape, input1, 1.0f, 0,
                                      shape, output, 1.0f, 0);
 }
 
-LayerTestResult<float, 4> DivisionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> DivisionBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int shape0[] = { 1, 2, 2, 2 };
     std::vector<float> input0({ 2, 4, 6, 8, 10, 12, 14, 16});
@@ -1412,12 +1550,15 @@
 
 
     return DivisionTestHelper<float>(workloadFactory,
+                                     memoryManager,
                                      shape0, input0, 1.0f, 0,
                                      shape1, input1, 1.0f, 0,
                                      shape0, output, 1.0f, 0);
 }
 
-LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int shape0[] = { 1, 3, 3, 2 };
     std::vector<float> input0({
@@ -1434,13 +1575,16 @@
                                       13, 14,     15, 16,     17, 18});
 
     return DivisionTestHelper<float>(workloadFactory,
+                                     memoryManager,
                                      shape0, input0, 1.0f, 0,
                                      shape1, input1, 1.0f, 0,
                                      shape0, output, 1.0f, 0);
 }
 
 
-LayerTestResult<uint8_t,4> DivisionUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t,4> DivisionUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int width = 2;
     const unsigned int height = 2;
@@ -1460,12 +1604,15 @@
 
 
     return DivisionTestHelper<uint8_t>(workloadFactory,
-                                     shape, input0, 1.0f,  0,
-                                     shape, input1, 1.0f,  0,
-                                     shape, output, 0.25f, 0);
+                                       memoryManager,
+                                      shape, input0, 1.0f,  0,
+                                      shape, input1, 1.0f,  0,
+                                      shape, output, 0.25f, 0);
 }
 
-LayerTestResult<uint8_t, 4> DivisionBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> DivisionBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int shape0[] = { 1, 2, 2, 2 };
     std::vector<uint8_t> input0({ 2, 4, 6, 8, 10, 12, 14, 16});
@@ -1476,12 +1623,15 @@
     std::vector<uint8_t> output({ 1, 2, 3, 4, 5, 6, 7, 8});
 
     return DivisionTestHelper<uint8_t>(workloadFactory,
-                                     shape0, input0, 1.0f, 0,
-                                     shape1, input1, 1.0f, 0,
-                                     shape0, output, 1.0f, 0);
+                                       memoryManager,
+                                       shape0, input0, 1.0f, 0,
+                                       shape1, input1, 1.0f, 0,
+                                       shape0, output, 1.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> DivisionBroadcast1DVectorUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> DivisionBroadcast1DVectorUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int shape0[] = { 1, 3, 3, 2 };
     std::vector<uint8_t> input0({1,   4,     3,  8,      5,  12,
@@ -1496,19 +1646,22 @@
                                  13, 14,     15, 16,     17, 18});
 
     return DivisionTestHelper<uint8_t>(workloadFactory,
-                                     shape0, input0, 1.0f, 0,
-                                     shape1, input1, 1.0f, 0,
-                                     shape0, output, 1.0f, 0);
+                                       memoryManager,
+                                       shape0, input0, 1.0f, 0,
+                                       shape1, input1, 1.0f, 0,
+                                       shape0, output, 1.0f, 0);
 }
 
 namespace {
-LayerTestResult<float,4> MultiplicationTestHelper(armnn::IWorkloadFactory& workloadFactory,
-                                                  const unsigned int shape0[4],
-                                                  const std::vector<float> & values0,
-                                                  const unsigned int shape1[4],
-                                                  const std::vector<float> & values1,
-                                                  const unsigned int outShape[4],
-                                                  const std::vector<float> & outValues)
+LayerTestResult<float,4> MultiplicationTestHelper(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const unsigned int shape0[4],
+    const std::vector<float> & values0,
+    const unsigned int shape1[4],
+    const std::vector<float> & values1,
+    const unsigned int outShape[4],
+    const std::vector<float> & outValues)
 {
     const size_t dimensionCount = 4;
     armnn::TensorInfo inputTensorInfo0{dimensionCount, shape0, armnn::DataType::Float32};
@@ -1549,7 +1702,9 @@
 } // anonymous namespace
 
 
-LayerTestResult<float,4> MultiplicationTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float,4> MultiplicationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int width = 2;
     const unsigned int height = 2;
@@ -1571,6 +1726,7 @@
         12, 12, 12, 12,  20, 20, 20, 20 });
 
     return MultiplicationTestHelper(workloadFactory,
+                                    memoryManager,
                                     shape,
                                     input0,
                                     shape,
@@ -1579,7 +1735,9 @@
                                     output);
 }
 
-LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int shape0[] = { 1, 2, 2, 2 };
     std::vector<float> input0({ 1, 2, 3, 4, 5, 6, 7, 8});
@@ -1590,6 +1748,7 @@
     std::vector<float> output({ 2, 4, 6, 8, 10, 12, 14, 16});
 
     return MultiplicationTestHelper(workloadFactory,
+                                    memoryManager,
                                     shape0,
                                     input0,
                                     shape1,
@@ -1598,7 +1757,9 @@
                                     output);
 }
 
-LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int shape0[] = { 1, 3, 3, 2 };
     std::vector<float> input0({
@@ -1615,6 +1776,7 @@
         13,  28,     15, 32,     17, 36});
 
     return MultiplicationTestHelper(workloadFactory,
+                                    memoryManager,
                                     shape0,
                                     input0,
                                     shape1,
@@ -1623,8 +1785,10 @@
                                     output);
 }
 
-LayerTestResult<float,4> CompareMultiplicationTest(armnn::IWorkloadFactory& workloadFactory,
-                                          armnn::IWorkloadFactory& refWorkloadFactory)
+LayerTestResult<float,4> CompareMultiplicationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory)
 {
     const unsigned int width = 16;
     const unsigned int height = 32;
@@ -1690,8 +1854,10 @@
     return comparisonResult;
 }
 
-LayerTestResult<float,4> CompareBatchNormTest(armnn::IWorkloadFactory& workloadFactory,
-                                     armnn::IWorkloadFactory& refWorkloadFactory)
+LayerTestResult<float,4> CompareBatchNormTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory)
 {
     const unsigned int width     = 2;
     const unsigned int height    = 3;
@@ -1772,6 +1938,7 @@
 template<typename T>
 void PermuteTensorData(
         armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
         const armnn::PermutationVector& mappings,
         armnn::TensorInfo & inputTensorInfo,
         const T * inputData,
@@ -1918,6 +2085,7 @@
 template <typename T>
 void PermuteInputsForConcat(
         armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
         std::vector<armnn::TensorInfo> & inputTensorInfos,
         std::vector<T *> & inputData,
         std::vector<std::vector<T>> & inputDataStorage,
@@ -1958,6 +2126,7 @@
         newTensorInfo.SetShape(ExpandTensorShapeTo3dForPermute(tensorInfo.GetShape()));
 
         PermuteTensorData<T>(workloadFactory,
+                             memoryManager,
                              permutations.first,
                              newTensorInfo,
                              inputData[nthInput],
@@ -1984,6 +2153,7 @@
 template <typename T>
 void PermuteOutputForConcat(
         armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
         const armnn::TensorInfo & tensorInfo,
         const armnn::PermutationVector & permuteVector,
         std::unique_ptr<armnn::ITensorHandle> && inputDataHandle,
@@ -2005,6 +2175,7 @@
     CopyDataFromITensorHandle(&inputData[0], inputDataHandle.get());
 
     PermuteTensorData<T>(workloadFactory,
+                         memoryManager,
                          permuteVector,
                          resultTensorInfo,
                          &inputData[0],
@@ -2014,12 +2185,14 @@
 }
 
 template <typename T>
-void Concatenate(armnn::IWorkloadFactory& workloadFactory,
-                 std::initializer_list<const armnn::TensorInfo> inputTensorInfosOrig,
-                 std::initializer_list<T *> inputsOrig,
-                 const armnn::TensorInfo& outputTensorInfoOrig,
-                 T * output,
-                 unsigned int concatDim)
+void Concatenate(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    std::initializer_list<const armnn::TensorInfo> inputTensorInfosOrig,
+    std::initializer_list<T *> inputsOrig,
+    const armnn::TensorInfo& outputTensorInfoOrig,
+    T * output,
+    unsigned int concatDim)
 {
     BOOST_ASSERT_MSG(output != nullptr, "output must not be null");
     if (output == nullptr)
@@ -2053,6 +2226,7 @@
         // the requested axis is not supported.
         //
         PermuteInputsForConcat<T>(workloadFactory,
+                                  memoryManager,
                                   inputTensorInfos,
                                   inputs,
                                   tmpInputDataStorage,
@@ -2118,6 +2292,7 @@
     if (needPermuteForConcat)
     {
         PermuteOutputForConcat<T>(workloadFactory,
+                                  memoryManager,
                                   outputTensorInfo,
                                   permuteVector,
                                   std::move(outputHandle),
@@ -2130,7 +2305,11 @@
 }
 
 template <typename T>
-LayerTestResult<T, 1> Concatenation1dTestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
+LayerTestResult<T, 1> Concatenation1dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     armnn::TensorInfo inputTensorInfo({ 3 }, armnn::GetDataType<T>());
 
@@ -2144,7 +2323,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { inputTensorInfo, inputTensorInfo, inputTensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -2159,13 +2338,17 @@
     return result;
 }
 
-LayerTestResult<float, 1> Concatenation1dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 1> Concatenation1dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation1dTestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation1dTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 2> Concatenation2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<T, 2> Concatenation2dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::TensorInfo& outputTensorInfo,
     unsigned int dimension,
     const float qScale,
@@ -2201,7 +2384,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { inputTensorInfo, inputTensorInfo, inputTensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -2213,12 +2396,16 @@
 }
 
 template <typename T>
-LayerTestResult<T, 2> Concatenation2dDim0TestImpl(armnn::IWorkloadFactory& workloadFactory,
-    float qScale, int32_t qOffset)
+LayerTestResult<T, 2> Concatenation2dDim0TestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     armnn::TensorInfo outputTensorInfo({ 6, 3 }, armnn::GetDataType<T>());
 
-    LayerTestResult<T, 2> result = Concatenation2dTestImpl<T>(workloadFactory, outputTensorInfo, 0, qScale, qOffset);
+    LayerTestResult<T, 2> result =
+        Concatenation2dTestImpl<T>(workloadFactory, memoryManager, outputTensorInfo, 0, qScale, qOffset);
     result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
         // Batch 0
         1.0f, 2.0f, 3.0f,
@@ -2242,18 +2429,24 @@
     return result;
 }
 
-LayerTestResult<float, 2> Concatenation2dDim0Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 2> Concatenation2dDim0Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim0TestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation2dDim0TestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 2> Concatenation2dDim1TestImpl(armnn::IWorkloadFactory& workloadFactory,
-    float qScale, int32_t qOffset)
+LayerTestResult<T, 2> Concatenation2dDim1TestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     armnn::TensorInfo outputTensorInfo({ 2, 9 }, armnn::GetDataType<T>());
 
-    LayerTestResult<T, 2> result = Concatenation2dTestImpl<T>(workloadFactory, outputTensorInfo, 1, qScale, qOffset);
+    LayerTestResult<T, 2> result =
+        Concatenation2dTestImpl<T>(workloadFactory, memoryManager, outputTensorInfo, 1, qScale, qOffset);
     result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
         // Batch 0
         1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
@@ -2265,13 +2458,18 @@
     return result;
 }
 
-LayerTestResult<float, 2> Concatenation2dDim1Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 2> Concatenation2dDim1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim1TestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation2dDim1TestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 2> Concatenation2dDim0DiffInputDimsTestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale,
+LayerTestResult<T, 2> Concatenation2dDim0DiffInputDimsTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
     int32_t qOffset)
 {
     armnn::TensorInfo input0TensorInfo({ 2, 3 }, armnn::GetDataType<T>());
@@ -2306,7 +2504,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { input0TensorInfo, input1TensorInfo, input2TensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -2337,13 +2535,18 @@
     return result;
 }
 
-LayerTestResult<float, 2> Concatenation2dDim0DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 2> Concatenation2dDim0DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim0DiffInputDimsTestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation2dDim0DiffInputDimsTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 2> Concatenation2dDim1DiffInputDimsTestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale,
+LayerTestResult<T, 2> Concatenation2dDim1DiffInputDimsTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
     int32_t qOffset)
 {
     armnn::TensorInfo input0TensorInfo({ 2, 3 }, armnn::GetDataType<T>());
@@ -2378,7 +2581,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { input0TensorInfo, input1TensorInfo, input2TensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -2397,13 +2600,17 @@
     return result;
 }
 
-LayerTestResult<float, 2> Concatenation2dDim1DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 2> Concatenation2dDim1DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim1DiffInputDimsTestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation2dDim1DiffInputDimsTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 3> Concatenation3dTestImpl(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<T, 3> Concatenation3dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::TensorInfo& outputTensorInfo,
     unsigned int dimension,
     float qScale,
@@ -2475,7 +2682,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { inputTensorInfo, inputTensorInfo, inputTensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -2487,13 +2694,16 @@
 }
 
 template <typename T>
-LayerTestResult<T, 3> Concatenation3dDim0TestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale,
+LayerTestResult<T, 3> Concatenation3dDim0TestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
     int32_t qOffset)
 {
     armnn::TensorInfo outputTensorInfo({ 6, 3, 2 }, armnn::GetDataType<T>());
 
-    LayerTestResult<T, 3> result = Concatenation3dTestImpl<T>(workloadFactory, outputTensorInfo, 0,
-        qScale, qOffset);
+    LayerTestResult<T, 3> result =
+        Concatenation3dTestImpl<T>(workloadFactory, memoryManager, outputTensorInfo, 0, qScale, qOffset);
     result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
         // Batch 0, Channel 0
         1.0f, 2.0f,
@@ -2552,18 +2762,24 @@
     return result;
 }
 
-LayerTestResult<float, 3> Concatenation3dDim0Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> Concatenation3dDim0Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim0TestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation3dDim0TestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 3> Concatenation3dDim1TestImpl(armnn::IWorkloadFactory& workloadFactory,
-    float qScale, int32_t qOffset)
+LayerTestResult<T, 3> Concatenation3dDim1TestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     armnn::TensorInfo outputTensorInfo({ 2, 9, 2 }, armnn::GetDataType<T>());
 
-    LayerTestResult<T, 3> result = Concatenation3dTestImpl<T>(workloadFactory, outputTensorInfo, 1, qScale, qOffset);
+    LayerTestResult<T, 3> result =
+        Concatenation3dTestImpl<T>(workloadFactory, memoryManager, outputTensorInfo, 1, qScale, qOffset);
     result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
         // Batch 0, Channel 0
         1.0f, 2.0f,
@@ -2623,18 +2839,24 @@
     return result;
 }
 
-LayerTestResult<float, 3> Concatenation3dDim1Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> Concatenation3dDim1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim1TestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation3dDim1TestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 3> Concatenation3dDim2TestImpl(armnn::IWorkloadFactory& workloadFactory,
-    float qScale, int32_t qOffset)
+LayerTestResult<T, 3> Concatenation3dDim2TestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     armnn::TensorInfo outputTensorInfo({ 2, 3, 6 }, armnn::GetDataType<T>());
 
-    LayerTestResult<T, 3> result = Concatenation3dTestImpl<T>(workloadFactory, outputTensorInfo, 2, qScale, qOffset);
+    LayerTestResult<T, 3> result =
+        Concatenation3dTestImpl<T>(workloadFactory, memoryManager, outputTensorInfo, 2, qScale, qOffset);
     result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
         // Batch 0, Channel 0
         1.0f, 2.0f, 7.0f, 8.0f, 13.0f, 14.0f,
@@ -2658,13 +2880,18 @@
     return result;
 }
 
-LayerTestResult<float, 3> Concatenation3dDim2Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> Concatenation3dDim2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim2TestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation3dDim2TestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 3> Concatenation3dDim0DiffInputDimsTestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale,
+LayerTestResult<T, 3> Concatenation3dDim0DiffInputDimsTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
     int32_t qOffset)
 {
     armnn::TensorInfo input0TensorInfo({ 2, 3, 2 }, armnn::GetDataType<T>());
@@ -2735,7 +2962,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { input0TensorInfo, input1TensorInfo, input2TensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -2802,13 +3029,18 @@
     return result;
 }
 
-LayerTestResult<float, 3> Concatenation3dDim0DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> Concatenation3dDim0DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim0DiffInputDimsTestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation3dDim0DiffInputDimsTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 3> Concatenation3dDim1DiffInputDimsTestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale,
+LayerTestResult<T, 3> Concatenation3dDim1DiffInputDimsTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
     int32_t qOffset)
 {
     armnn::TensorInfo input0TensorInfo({ 2, 3, 2 }, armnn::GetDataType<T>());
@@ -2873,7 +3105,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { input0TensorInfo, input1TensorInfo, input2TensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -2934,13 +3166,18 @@
     return result;
 }
 
-LayerTestResult<float, 3> Concatenation3dDim1DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> Concatenation3dDim1DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim1DiffInputDimsTestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation3dDim1DiffInputDimsTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
 template <typename T>
-LayerTestResult<T, 3> Concatenation3dDim2DiffInputDimsTestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale,
+LayerTestResult<T, 3> Concatenation3dDim2DiffInputDimsTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
     int32_t qOffset)
 {
     armnn::TensorInfo input0TensorInfo({ 2, 3, 2 }, armnn::GetDataType<T>());
@@ -3011,7 +3248,7 @@
 
     std::vector<T> output;
     output.resize(outputTensorInfo.GetNumElements());
-    Concatenate<T>(workloadFactory,
+    Concatenate<T>(workloadFactory, memoryManager,
         { input0TensorInfo, input1TensorInfo, input2TensorInfo },
         { input0.data(), input1.data(), input2.data() },
         outputTensorInfo,
@@ -3042,13 +3279,17 @@
     return result;
 }
 
-LayerTestResult<float, 3> Concatenation3dDim2DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> Concatenation3dDim2DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim2DiffInputDimsTestImpl<float>(workloadFactory, 0.0f, 0);
+    return Concatenation3dDim2DiffInputDimsTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<float, 4> ResizeBilinearNopTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> ResizeBilinearNopTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
     const armnn::TensorInfo inputTensorInfo = GetTensorInfo<float>(1, 2, 4, 4, dataLayout);
     const armnn::TensorInfo outputTensorInfo = GetTensorInfo<float>(1, 2, 4, 4, dataLayout);
@@ -3099,8 +3340,10 @@
     return result;
 }
 
-LayerTestResult<float, 4> SimpleResizeBilinearTest(armnn::IWorkloadFactory& workloadFactory,
-                                                   const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> SimpleResizeBilinearTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
     const armnn::TensorInfo inputTensorInfo = GetTensorInfo<float>(1, 2, 2, 2, dataLayout);
     const armnn::TensorInfo outputTensorInfo = GetTensorInfo<float>(1, 2, 1, 1, dataLayout);
@@ -3163,8 +3406,10 @@
     return result;
 }
 
-LayerTestResult<float, 4> ResizeBilinearSqMinTest(armnn::IWorkloadFactory& workloadFactory,
-                                                  const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> ResizeBilinearSqMinTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
     const armnn::TensorInfo inputTensorInfo = GetTensorInfo<float>(1, 2, 4, 4, dataLayout);
     const armnn::TensorInfo outputTensorInfo = GetTensorInfo<float>(1, 2, 2, 2, dataLayout);
@@ -3227,8 +3472,10 @@
     return result;
 }
 
-LayerTestResult<float, 4> ResizeBilinearMinTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> ResizeBilinearMinTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
     const armnn::TensorInfo inputTensorInfo = GetTensorInfo<float>(1, 2, 3, 5, dataLayout);
     const armnn::TensorInfo outputTensorInfo = GetTensorInfo<float>(1, 2, 2, 3, dataLayout);
@@ -3289,8 +3536,10 @@
     return result;
 }
 
-LayerTestResult<float, 4> ResizeBilinearMagTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> ResizeBilinearMagTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
     const armnn::TensorInfo inputTensorInfo = GetTensorInfo<float>(1, 2, 3, 2, dataLayout);
     const armnn::TensorInfo outputTensorInfo = GetTensorInfo<float>(1, 2, 3, 5, dataLayout);
@@ -3353,7 +3602,9 @@
     return result;
 }
 
-LayerTestResult<float, 2> FakeQuantizationTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 2> FakeQuantizationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     constexpr unsigned int width = 2;
     constexpr unsigned int height = 3;
@@ -3410,11 +3661,13 @@
 namespace
 {
 
-LayerTestResult<float, 4> L2NormalizationTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                  const armnn::TensorShape& inputOutputTensorShape,
-                                                  const std::vector<float>& inputValues,
-                                                  const std::vector<float>& expectedOutputValues,
-                                                  const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> L2NormalizationTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::TensorShape& inputOutputTensorShape,
+    const std::vector<float>& inputValues,
+    const std::vector<float>& expectedOutputValues,
+    const armnn::DataLayoutIndexed& layout)
 {
     const armnn::TensorInfo inputTensorInfo(inputOutputTensorShape, armnn::DataType::Float32);
     const armnn::TensorInfo outputTensorInfo(inputOutputTensorShape, armnn::DataType::Float32);
@@ -3458,9 +3711,7 @@
 
     CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
 
@@ -3477,7 +3728,11 @@
 } // anonymous namespace
 
 template<typename T>
-LayerTestResult<T, 2> Pad2dTestCommon(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
+LayerTestResult<T, 2> Pad2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
   const armnn::TensorShape inputShape{ 3, 3 };
   const armnn::TensorShape outputShape{ 7, 7 };
@@ -3541,7 +3796,11 @@
 }
 
 template <typename T>
-LayerTestResult<T, 3> Pad3dTestCommon(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
+LayerTestResult<T, 3> Pad3dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     const armnn::TensorShape inputShape{ 2, 2, 2 };
     const armnn::TensorShape outputShape{ 3, 5, 6 };
@@ -3621,7 +3880,11 @@
 }
 
 template <typename T>
-LayerTestResult<T, 4> Pad4dTestCommon(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
+LayerTestResult<T, 4> Pad4dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale,
+    int32_t qOffset)
 {
     const armnn::TensorShape inputShape{ 2, 2, 3, 2 };
     const armnn::TensorShape outputShape{ 4, 5, 7, 4 };
@@ -3853,38 +4116,52 @@
     return result;
 }
 
-LayerTestResult<uint8_t, 2> PadUint82dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 2> PadUint82dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-  return Pad2dTestCommon<uint8_t>(workloadFactory, 1.0f, 0);
+  return Pad2dTestCommon<uint8_t>(workloadFactory, memoryManager, 1.0f, 0);
 }
 
-LayerTestResult<uint8_t, 3> PadUint83dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> PadUint83dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-  return Pad3dTestCommon<uint8_t>(workloadFactory, 1.0f, 0);
+  return Pad3dTestCommon<uint8_t>(workloadFactory, memoryManager, 1.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> PadUint84dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> PadUint84dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-  return Pad4dTestCommon<uint8_t>(workloadFactory, 1.0f, 0);
+  return Pad4dTestCommon<uint8_t>(workloadFactory, memoryManager, 1.0f, 0);
 }
 
-LayerTestResult<float, 2> PadFloat322dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 2> PadFloat322dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-  return Pad2dTestCommon<float>(workloadFactory, 0.0f, 0);
+  return Pad2dTestCommon<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<float, 3> PadFloat323dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> PadFloat323dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-  return Pad3dTestCommon<float>(workloadFactory, 0.0f, 0);
+  return Pad3dTestCommon<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<float, 4> PadFloat324dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> PadFloat324dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-  return Pad4dTestCommon<float>(workloadFactory, 0.0f, 0);
+  return Pad4dTestCommon<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<float, 4> L2Normalization1dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> L2Normalization1dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout)
 {
     // Width: 1
     // Height: 1
@@ -3946,12 +4223,15 @@
         10.0f * approxInvL2Norm
     };
 
-    return L2NormalizationTestImpl(workloadFactory, inputOutputShape,
+
+    return L2NormalizationTestImpl(workloadFactory, memoryManager, inputOutputShape,
                                    inputValues, expectedOutputValues, layout);
 }
 
-LayerTestResult<float, 4> L2Normalization2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> L2Normalization2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout)
 {
     // Width: 5
     // Height: 1
@@ -3989,12 +4269,14 @@
         10.0f * CalcInvL2Norm({ 9.0f, 10.0f })
     };
 
-    return L2NormalizationTestImpl(workloadFactory, inputOutputShape,
+    return L2NormalizationTestImpl(workloadFactory, memoryManager, inputOutputShape,
                                    inputValues, expectedOutputValues, layout);
 }
 
-LayerTestResult<float, 4> L2Normalization3dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> L2Normalization3dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout)
 {
     // Width: 3
     // Height: 4
@@ -4052,14 +4334,16 @@
         161.0f * CalcInvL2Norm({ 220.0f, 161.0f })
     };
 
-    return L2NormalizationTestImpl(workloadFactory, inputOutputShape,
+    return L2NormalizationTestImpl(workloadFactory, memoryManager, inputOutputShape,
                                    inputValues, expectedOutputValues, layout);
 }
 
-LayerTestResult<float, 4> L2Normalization4dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout)
+LayerTestResult<float, 4> L2Normalization4dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout)
 {
-    // Width: 3
+        // Width: 3
     // Height: 4
     // Channels: 3
     // BatchSize: 2
@@ -4195,12 +4479,14 @@
          88.0f * CalcInvL2Norm({ 189.0f,  21.0f,  88.0f })
     };
 
-    return L2NormalizationTestImpl(workloadFactory, inputOutputShape,
+    return L2NormalizationTestImpl(workloadFactory, memoryManager, inputOutputShape,
                                    inputValues, expectedOutputValues, layout);
 }
 
 template <typename T>
-LayerTestResult<T, 4> ConstantTestImpl(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<T, 4> ConstantTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     float qScale,
     int32_t qOffset)
 {
@@ -4292,17 +4578,23 @@
     return result;
 }
 
-LayerTestResult<float, 4> ConstantTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> ConstantTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return ConstantTestImpl<float>(workloadFactory, 0.0f, 0);
+    return ConstantTestImpl<float>(workloadFactory, memoryManager, 0.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> ConstantTestUint8(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> ConstantTestUint8(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return ConstantTestImpl<uint8_t>(workloadFactory, 1.0f, 0);
+    return ConstantTestImpl<uint8_t>(workloadFactory, memoryManager, 1.0f, 0);
 }
 
-LayerTestResult<uint8_t, 3> MergerUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> MergerUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int outputWidth = 3;
     unsigned int outputHeight = 6;
@@ -4435,7 +4727,9 @@
     return ret;
 }
 
-LayerTestResult<uint8_t, 4> AdditionUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> AdditionUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int batchSize = 1;
     unsigned int channels = 2;
@@ -4511,19 +4805,21 @@
 
 namespace
 {
-LayerTestResult<uint8_t, 4> MultiplicationUint8TestHelper(armnn::IWorkloadFactory& workloadFactory,
-                                                          const unsigned int shape0[4],
-                                                          const std::vector<uint8_t> & values0,
-                                                          float scale0,
-                                                          int32_t offset0,
-                                                          const unsigned int shape1[4],
-                                                          const std::vector<uint8_t> & values1,
-                                                          float scale1,
-                                                          int32_t offset1,
-                                                          const unsigned int outShape[4],
-                                                          const std::vector<uint8_t> & outValues,
-                                                          float outScale,
-                                                          int32_t outOffset)
+LayerTestResult<uint8_t, 4> MultiplicationUint8TestHelper(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const unsigned int shape0[4],
+    const std::vector<uint8_t> & values0,
+    float scale0,
+    int32_t offset0,
+    const unsigned int shape1[4],
+    const std::vector<uint8_t> & values1,
+    float scale1,
+    int32_t offset1,
+    const unsigned int outShape[4],
+    const std::vector<uint8_t> & outValues,
+    float outScale,
+    int32_t outOffset)
 {
     armnn::TensorInfo inputTensorInfo0(4, shape0, armnn::DataType::QuantisedAsymm8);
     armnn::TensorInfo inputTensorInfo1(4, shape1, armnn::DataType::QuantisedAsymm8);
@@ -4571,7 +4867,9 @@
 }
 } // anonymous namespace
 
-LayerTestResult<uint8_t, 4> MultiplicationUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> MultiplicationUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     unsigned int batchSize = 1;
     unsigned int channels = 2;
@@ -4599,6 +4897,7 @@
     });
 
     return MultiplicationUint8TestHelper(workloadFactory,
+                                         memoryManager,
                                          shape,
                                          input0,
                                          4.0f,
@@ -4613,7 +4912,9 @@
                                          -5);
 }
 
-LayerTestResult<uint8_t, 4> MultiplicationBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> MultiplicationBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 2, 2, 3 };
     const unsigned int shape1[] = { 1, 1, 1, 1 };
@@ -4631,6 +4932,7 @@
     });
 
     return MultiplicationUint8TestHelper(workloadFactory,
+                                         memoryManager,
                                          shape0,
                                          input0,
                                          1.0f,
@@ -4645,7 +4947,9 @@
                                          0);
 }
 
-LayerTestResult<uint8_t, 4> MultiplicationBroadcast1DVectorUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> MultiplicationBroadcast1DVectorUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 2, 2, 3 };
     const unsigned int shape1[] = { 1, 1, 1, 3 };
@@ -4663,6 +4967,7 @@
     });
 
     return MultiplicationUint8TestHelper(workloadFactory,
+                                         memoryManager,
                                          shape0,
                                          input0,
                                          1.0f,
@@ -4680,19 +4985,21 @@
 namespace
 {
 template <typename T>
-LayerTestResult<T, 4> SubtractionTestHelper(armnn::IWorkloadFactory& workloadFactory,
-                                            const unsigned int shape0[4],
-                                            const std::vector<T>& values0,
-                                            float scale0,
-                                            int32_t offset0,
-                                            const unsigned int shape1[4],
-                                            const std::vector<T> & values1,
-                                            float scale1,
-                                            int32_t offset1,
-                                            const unsigned int outShape[4],
-                                            const std::vector<T> & outValues,
-                                            float outScale,
-                                            int32_t outOffset)
+LayerTestResult<T, 4> SubtractionTestHelper(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const unsigned int shape0[4],
+    const std::vector<T>& values0,
+    float scale0,
+    int32_t offset0,
+    const unsigned int shape1[4],
+    const std::vector<T> & values1,
+    float scale1,
+    int32_t offset1,
+    const unsigned int outShape[4],
+    const std::vector<T> & outValues,
+    float outScale,
+    int32_t outOffset)
 {
     auto dataType = (std::is_same<T, uint8_t>::value ?
                      armnn::DataType::QuantisedAsymm8 :
@@ -4744,7 +5051,9 @@
 }
 } // anonymous namespace
 
-LayerTestResult<uint8_t, 4> SubtractionUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SubtractionUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 1, 2, 2 };
     const unsigned int shape1[] = { 1, 1, 2, 2 };
@@ -4754,12 +5063,15 @@
     std::vector<uint8_t> output({ 3, 3, 5, 5 });
 
     return SubtractionTestHelper(workloadFactory,
+                                 memoryManager,
                                  shape0, input0, 0.5f, 2,
                                  shape1, input1, 1.0f, 0,
                                  shape0, output, 1.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> SubtractionBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SubtractionBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 1, 2, 2 };
     const unsigned int shape1[] = { 1, 1, 1, 1 };
@@ -4769,12 +5081,15 @@
     std::vector<uint8_t> output({ 5, 6, 7, 8 });
 
     return SubtractionTestHelper(workloadFactory,
+                                 memoryManager,
                                  shape0, input0, 0.5f, 2,
                                  shape1, input1, 1.0f, 0,
                                  shape0, output, 1.0f, 3);
 }
 
-LayerTestResult<uint8_t, 4> SubtractionBroadcastUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SubtractionBroadcastUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 1, 2, 2 };
     const unsigned int shape1[] = { 1, 1, 2, 1 };
@@ -4784,12 +5099,15 @@
     std::vector<uint8_t> output({ 8, 11, 12, 15 });
 
     return SubtractionTestHelper(workloadFactory,
+                                 memoryManager,
                                  shape0, input0, 1.0f, 0,
                                  shape1, input1, 1.0f, 0,
                                  shape0, output, 1.0f, 0);
 }
 
-LayerTestResult<float, 4> SubtractionTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SubtractionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 1, 2, 2 };
     const unsigned int shape1[] = { 1, 1, 2, 2 };
@@ -4799,12 +5117,15 @@
     std::vector<float> output({ 0,  3, 3, 2 });
 
     return SubtractionTestHelper(workloadFactory,
+                                 memoryManager,
                                  shape0, input0, 1.0f, 0,
                                  shape1, input1, 1.0f, 0,
                                  shape0, output, 1.0f, 0);
 }
 
-LayerTestResult<float, 4> SubtractionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SubtractionBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 1, 2, 2 };
     const unsigned int shape1[] = { 1, 1, 1, 1 };
@@ -4814,12 +5135,15 @@
     std::vector<float> output({ -9,  -8, -7, -6 });
 
     return SubtractionTestHelper(workloadFactory,
+                                 memoryManager,
                                  shape0, input0, 1.0f, 0,
                                  shape1, input1, 1.0f, 0,
                                  shape0, output, 1.0f, 0);
 }
 
-LayerTestResult<float, 4> SubtractionBroadcastTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SubtractionBroadcastTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int shape0[] = { 1, 1, 2, 2 };
     const unsigned int shape1[] = { 1, 1, 1, 2 };
@@ -4829,12 +5153,15 @@
     std::vector<float> output({ -9,  7, -7, 9 });
 
     return SubtractionTestHelper(workloadFactory,
+                                 memoryManager,
                                  shape0, input0, 1.0f, 0,
                                  shape1, input1, 1.0f, 0,
                                  shape0, output, 1.0f, 0);
 }
 
-LayerTestResult<uint8_t, 4> ResizeBilinearNopUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> ResizeBilinearNopUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     constexpr unsigned int inputWidth = 4;
     constexpr unsigned int inputHeight = 4;
@@ -4886,7 +5213,9 @@
     return result;
 }
 
-LayerTestResult<uint8_t, 4> SimpleResizeBilinearUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SimpleResizeBilinearUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     constexpr unsigned int inputWidth = 2;
     constexpr unsigned int inputHeight = 2;
@@ -4943,7 +5272,9 @@
     return result;
 }
 
-LayerTestResult<uint8_t, 4> ResizeBilinearSqMinUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> ResizeBilinearSqMinUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     constexpr unsigned int inputWidth = 4;
     constexpr unsigned int inputHeight = 4;
@@ -4998,7 +5329,9 @@
     return result;
 }
 
-LayerTestResult<uint8_t, 4> ResizeBilinearMinUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> ResizeBilinearMinUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     constexpr unsigned int inputWidth = 3;
     constexpr unsigned int inputHeight = 2;
@@ -5051,7 +5384,9 @@
     return result;
 }
 
-LayerTestResult<uint8_t, 4> ResizeBilinearMagUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> ResizeBilinearMagUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     constexpr unsigned int inputWidth = 2;
     constexpr unsigned int inputHeight = 3;
@@ -5106,7 +5441,9 @@
     return result;
 }
 
-LayerTestResult<float, 4> BatchNormTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> BatchNormTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     // BatchSize: 1
     // Channels: 2
@@ -5139,11 +5476,14 @@
         2.f, 4.f
     };
 
-    return BatchNormTestImpl<float>(workloadFactory, inputOutputShape, inputValues, expectedOutputValues,
+    return BatchNormTestImpl<float>(workloadFactory, memoryManager,
+                                    inputOutputShape, inputValues, expectedOutputValues,
                                     0.f, 0, armnn::DataLayout::NCHW);
 }
 
-LayerTestResult<float, 4> BatchNormNhwcTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> BatchNormNhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     // BatchSize: 1
     // Height: 3
@@ -5180,11 +5520,14 @@
         6.f, 4.f
     };
 
-    return BatchNormTestImpl<float>(workloadFactory, inputOutputShape, inputValues, expectedOutputValues,
+    return BatchNormTestImpl<float>(workloadFactory, memoryManager,
+                                    inputOutputShape, inputValues, expectedOutputValues,
                                     0.f, 0, armnn::DataLayout::NHWC);
 }
 
-LayerTestResult<uint8_t, 4> BatchNormUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> BatchNormUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     // BatchSize: 1
     // Channels: 2
@@ -5217,11 +5560,14 @@
         2.f, 4.f
     };
 
-    return BatchNormTestImpl<uint8_t>(workloadFactory, inputOutputShape, inputValues, expectedOutputValues,
+    return BatchNormTestImpl<uint8_t>(workloadFactory, memoryManager,
+                                      inputOutputShape, inputValues, expectedOutputValues,
                                       1.f/20.f, 50, armnn::DataLayout::NCHW);
 }
 
-LayerTestResult<uint8_t, 4> BatchNormUint8NhwcTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> BatchNormUint8NhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     // BatchSize: 1
     // Height: 3
@@ -5258,335 +5604,461 @@
         6.f, 4.f
     };
 
-    return BatchNormTestImpl<uint8_t>(workloadFactory, inputOutputShape, inputValues, expectedOutputValues,
+    return BatchNormTestImpl<uint8_t>(workloadFactory, memoryManager,
+                                      inputOutputShape, inputValues, expectedOutputValues,
                                       1.f/20.f, 50, armnn::DataLayout::NHWC);
 }
 
-LayerTestResult<uint8_t, 4> ConstantUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> ConstantUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return ConstantTestImpl<uint8_t>(workloadFactory, 2e-6f, 1);
+    return ConstantTestImpl<uint8_t>(workloadFactory, memoryManager, 2e-6f, 1);
 }
 
-LayerTestResult<uint8_t, 1> Concatenation1dUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 1> Concatenation1dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation1dTestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation1dTestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 2> Concatenation2dDim0Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 2> Concatenation2dDim0Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim0TestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation2dDim0TestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 2> Concatenation2dDim1Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 2> Concatenation2dDim1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim1TestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation2dDim1TestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 2> Concatenation2dDim0DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 2> Concatenation2dDim0DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim0DiffInputDimsTestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation2dDim0DiffInputDimsTestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 2> Concatenation2dDim1DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 2> Concatenation2dDim1DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation2dDim1DiffInputDimsTestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation2dDim1DiffInputDimsTestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 3> Concatenation3dDim0Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> Concatenation3dDim0Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim0TestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation3dDim0TestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 3> Concatenation3dDim1Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> Concatenation3dDim1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim1TestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation3dDim1TestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 3> Concatenation3dDim2Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> Concatenation3dDim2Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim2TestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation3dDim2TestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 3> Concatenation3dDim0DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> Concatenation3dDim0DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim0TestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation3dDim0TestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 3> Concatenation3dDim1DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> Concatenation3dDim1DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim1DiffInputDimsTestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation3dDim1DiffInputDimsTestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<uint8_t, 3> Concatenation3dDim2DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> Concatenation3dDim2DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return Concatenation3dDim2DiffInputDimsTestImpl<uint8_t>(workloadFactory, 0.5f, -1);
+    return Concatenation3dDim2DiffInputDimsTestImpl<uint8_t>(workloadFactory, memoryManager, 0.5f, -1);
 }
 
-LayerTestResult<float, 4> SimpleMaxPooling2dSize2x2Stride2x2Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                 bool forceNoPadding)
+LayerTestResult<float, 4> SimpleMaxPooling2dSize2x2Stride2x2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding)
 {
-    return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<float>(workloadFactory, forceNoPadding);
+    return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<float>(workloadFactory, memoryManager, forceNoPadding);
 }
 
-LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                        bool forceNoPadding)
+LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding)
 {
-    return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<uint8_t>(workloadFactory, forceNoPadding, 3.0f, -5);
+    return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<uint8_t>(
+        workloadFactory, memoryManager, forceNoPadding, 3.0f, -5);
 }
 
-LayerTestResult<float, 4> SimpleMaxPooling2dSize3x3Stride2x4Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                 bool forceNoPadding)
+LayerTestResult<float, 4> SimpleMaxPooling2dSize3x3Stride2x4Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding)
 {
-    return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<float>(workloadFactory, forceNoPadding);
+    return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<float>(workloadFactory, memoryManager, forceNoPadding);
 }
 
-LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                        bool forceNoPadding)
+LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding)
 {
-    return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<uint8_t>(workloadFactory, forceNoPadding, 0.1f, 128);
+    return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<uint8_t>(
+        workloadFactory, memoryManager, forceNoPadding, 0.1f, 128);
 }
 
-LayerTestResult<float, 4> SimpleMaxPooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                 const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> SimpleMaxPooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
-    return SimpleMaxPooling2dTestCommon<float>(workloadFactory, dataLayout);
+    return SimpleMaxPooling2dTestCommon<float>(workloadFactory, memoryManager, dataLayout);
 }
 
-LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                        const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
-    return SimpleMaxPooling2dTestCommon<uint8_t>(workloadFactory, dataLayout);
+    return SimpleMaxPooling2dTestCommon<uint8_t>(workloadFactory, memoryManager, dataLayout);
 }
 
-LayerTestResult<float, 4> SimpleAveragePooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                     const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> SimpleAveragePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
-    return SimpleAveragePooling2dTestCommon<float>(workloadFactory, dataLayout);
+    return SimpleAveragePooling2dTestCommon<float>(workloadFactory, memoryManager, dataLayout);
 }
 
-LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
-    return SimpleAveragePooling2dTestCommon<uint8_t>(workloadFactory, dataLayout, 0.5, -1);
+    return SimpleAveragePooling2dTestCommon<uint8_t>(
+        workloadFactory, memoryManager, dataLayout, 0.5, -1);
 }
 
-LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                            bool forceNoPadding)
+LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding)
 {
-    return IgnorePaddingAveragePooling2dSize3x2Stride2x2TestCommon<float>(workloadFactory, forceNoPadding);
+    return IgnorePaddingAveragePooling2dSize3x2Stride2x2TestCommon<float>(
+        workloadFactory, memoryManager, forceNoPadding);
 }
 
-LayerTestResult<float, 4> LargeTensorsAveragePooling2dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> LargeTensorsAveragePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return LargeTensorsAveragePooling2dTestCommon<float>(workloadFactory);
+    return LargeTensorsAveragePooling2dTestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return LargeTensorsAveragePooling2dTestCommon<uint8_t>(workloadFactory, 0.5, -1);
+    return LargeTensorsAveragePooling2dTestCommon<uint8_t>(workloadFactory, memoryManager, 0.5, -1);
 }
 
-LayerTestResult<float, 4> SimpleL2Pooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<float, 4> SimpleL2Pooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
-    return SimpleL2Pooling2dTestCommon<float>(workloadFactory, dataLayout);
+    return SimpleL2Pooling2dTestCommon<float>(workloadFactory, memoryManager, dataLayout);
 }
 
-LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                       const armnn::DataLayoutIndexed& dataLayout)
+LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout)
 {
-    return SimpleL2Pooling2dTestCommon<uint8_t>(workloadFactory, dataLayout);
+    return SimpleL2Pooling2dTestCommon<uint8_t>(workloadFactory, memoryManager, dataLayout);
 }
 
-LayerTestResult<float, 4> L2Pooling2dSize3Stride1Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> L2Pooling2dSize3Stride1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize3Stride1TestCommon<float>(workloadFactory);
+    return L2Pooling2dSize3Stride1TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize3Stride1TestCommon<uint8_t>(workloadFactory);
+    return L2Pooling2dSize3Stride1TestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> L2Pooling2dSize3Stride3Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> L2Pooling2dSize3Stride3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize3Stride3TestCommon<float>(workloadFactory);
+    return L2Pooling2dSize3Stride3TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize3Stride3TestCommon<uint8_t>(workloadFactory);
+    return L2Pooling2dSize3Stride3TestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> L2Pooling2dSize3Stride4Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> L2Pooling2dSize3Stride4Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize3Stride4TestCommon<float>(workloadFactory);
+    return L2Pooling2dSize3Stride4TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize3Stride4TestCommon<uint8_t>(workloadFactory);
+    return L2Pooling2dSize3Stride4TestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> L2Pooling2dSize7Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> L2Pooling2dSize7Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize7TestCommon<float>(workloadFactory);
+    return L2Pooling2dSize7TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize7TestCommon<uint8_t>(workloadFactory);
+    return L2Pooling2dSize7TestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> L2Pooling2dSize9Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> L2Pooling2dSize9Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize9TestCommon<float>(workloadFactory);
+    return L2Pooling2dSize9TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return L2Pooling2dSize9TestCommon<uint8_t>(workloadFactory);
+    return L2Pooling2dSize9TestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> AsymmetricNonSquarePooling2dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> AsymmetricNonSquarePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return AsymmetricNonSquarePooling2dTestCommon<float>(workloadFactory);
+    return AsymmetricNonSquarePooling2dTestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return AsymmetricNonSquarePooling2dTestCommon<uint8_t>(workloadFactory);
+    return AsymmetricNonSquarePooling2dTestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> ComparePooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                               armnn::IWorkloadFactory& refWorkloadFactory,
-                                               armnn::PoolingAlgorithm  poolingType)
+LayerTestResult<float, 4> ComparePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::PoolingAlgorithm  poolingType)
 {
-    return ComparePooling2dTestCommon<float>(workloadFactory, refWorkloadFactory, poolingType);
+    return ComparePooling2dTestCommon<float>(
+        workloadFactory, memoryManager, refWorkloadFactory, poolingType);
 }
 
-LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                      armnn::IWorkloadFactory& refWorkloadFactory,
-                                                      armnn::PoolingAlgorithm  poolingType)
+LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::PoolingAlgorithm  poolingType)
 {
-    return ComparePooling2dTestCommon<uint8_t>(workloadFactory, refWorkloadFactory, poolingType, 0.1f, 128);
+    return ComparePooling2dTestCommon<uint8_t>(
+        workloadFactory, memoryManager, refWorkloadFactory, poolingType, 0.1f, 128);
 }
 
-LayerTestResult<float, 2> FullyConnectedLargeTest(armnn::IWorkloadFactory& workloadFactory,
-                                                  bool transposeWeights)
+LayerTestResult<float, 2> FullyConnectedLargeTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool transposeWeights)
 {
-    return FullyConnectedLargeTestCommon<float>(workloadFactory, transposeWeights);
+    return FullyConnectedLargeTestCommon<float>(workloadFactory, memoryManager, transposeWeights);
 }
 
-LayerTestResult<float, 4> IgnorePaddingSimpleMaxPooling2dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> IgnorePaddingSimpleMaxPooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleMaxPooling2dTestCommon<float>(workloadFactory);
+    return IgnorePaddingSimpleMaxPooling2dTestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleMaxPooling2dTestCommon<uint8_t>(workloadFactory, 1.0f, -5);
+    return IgnorePaddingSimpleMaxPooling2dTestCommon<uint8_t>(workloadFactory, memoryManager, 1.0f, -5);
 }
 
-LayerTestResult<float, 4> IgnorePaddingMaxPooling2dSize3Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> IgnorePaddingMaxPooling2dSize3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingMaxPooling2dSize3TestCommon<float>(workloadFactory);
+    return IgnorePaddingMaxPooling2dSize3TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingMaxPooling2dSize3TestCommon<uint8_t>(workloadFactory, 1.0f, -5);
+    return IgnorePaddingMaxPooling2dSize3TestCommon<uint8_t>(workloadFactory, memoryManager, 1.0f, -5);
 }
 
-LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleAveragePooling2dTestCommon<float>(workloadFactory);
+    return IgnorePaddingSimpleAveragePooling2dTestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleAveragePooling2dTestCommon<uint8_t>(workloadFactory);
+    return IgnorePaddingSimpleAveragePooling2dTestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<float>(workloadFactory);
+    return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<float>(workloadFactory, memoryManager);
 }
 
 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test(
-    armnn::IWorkloadFactory& workloadFactory)
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<uint8_t>(workloadFactory);
+    return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingAveragePooling2dSize3TestCommon<float>(workloadFactory);
+    return IgnorePaddingAveragePooling2dSize3TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingAveragePooling2dSize3TestCommon<uint8_t>(workloadFactory);
+    return IgnorePaddingAveragePooling2dSize3TestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> IgnorePaddingSimpleL2Pooling2dTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> IgnorePaddingSimpleL2Pooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleL2Pooling2dTestCommon<float>(workloadFactory);
+    return IgnorePaddingSimpleL2Pooling2dTestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingSimpleL2Pooling2dTestCommon<uint8_t>(workloadFactory);
+    return IgnorePaddingSimpleL2Pooling2dTestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> IgnorePaddingL2Pooling2dSize3Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> IgnorePaddingL2Pooling2dSize3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingL2Pooling2dSize3TestCommon<float>(workloadFactory);
+    return IgnorePaddingL2Pooling2dSize3TestCommon<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return IgnorePaddingL2Pooling2dSize3TestCommon<uint8_t>(workloadFactory);
+    return IgnorePaddingL2Pooling2dSize3TestCommon<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SimplePermuteFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SimplePermuteFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SimplePermuteFloat32TestCommon(workloadFactory);
+    return SimplePermuteFloat32TestCommon(workloadFactory, memoryManager);
 };
 
-LayerTestResult<uint8_t, 4> SimplePermuteUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SimplePermuteUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SimplePermuteUint8TestCommon(workloadFactory);
+    return SimplePermuteUint8TestCommon(workloadFactory, memoryManager);
 };
 
-LayerTestResult<float, 4> PermuteFloat32ValueSet1Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> PermuteFloat32ValueSet1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return PermuteFloat32ValueSet1TestCommon(workloadFactory);
+    return PermuteFloat32ValueSet1TestCommon(workloadFactory, memoryManager);
 };
 
-LayerTestResult<float, 4> PermuteFloat32ValueSet2Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> PermuteFloat32ValueSet2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return PermuteFloat32ValueSet2TestCommon(workloadFactory);
+    return PermuteFloat32ValueSet2TestCommon(workloadFactory, memoryManager);
 };
 
-LayerTestResult<float, 4> PermuteFloat32ValueSet3Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> PermuteFloat32ValueSet3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return PermuteFloat32ValueSet3TestCommon(workloadFactory);
+    return PermuteFloat32ValueSet3TestCommon(workloadFactory, memoryManager);
 };
 
 namespace
 {
 
 template <typename T, std::size_t InputDim, std::size_t OutputDim>
-LayerTestResult<T, OutputDim> MeanTestHelper(armnn::IWorkloadFactory& workloadFactory,
-                                             const unsigned int* inputShape,
-                                             const std::vector<T>& inputData,
-                                             const std::vector<unsigned int>& axis,
-                                             bool keepDims,
-                                             const unsigned int* outputShape,
-                                             const std::vector<T>& outputData,
-                                             float scale = 1.0f,
-                                             int32_t offset = 0)
+LayerTestResult<T, OutputDim> MeanTestHelper(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const unsigned int* inputShape,
+    const std::vector<T>& inputData,
+    const std::vector<unsigned int>& axis,
+    bool keepDims,
+    const unsigned int* outputShape,
+    const std::vector<T>& outputData,
+    float scale = 1.0f,
+    int32_t offset = 0)
 {
     auto dataType = (std::is_same<T, uint8_t>::value ? armnn::DataType::QuantisedAsymm8 : armnn::DataType::Float32);
 
@@ -5630,7 +6102,9 @@
 
 } // anonymous namespace
 
-LayerTestResult<uint8_t, 1> MeanUint8SimpleTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 1> MeanUint8SimpleTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 3, 2 };
     const unsigned int outputShape[] = { 1 };
@@ -5638,10 +6112,13 @@
     std::vector<uint8_t> input({ 1, 1, 2, 2, 3, 3 });
     std::vector<uint8_t> output({ 2 });
 
-    return MeanTestHelper<uint8_t, 2, 1>(workloadFactory, inputShape, input, {}, false, outputShape, output);
+    return MeanTestHelper<uint8_t, 2, 1>(
+        workloadFactory, memoryManager, inputShape, input, {}, false, outputShape, output);
 }
 
-LayerTestResult<uint8_t, 3> MeanUint8SimpleAxisTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 3> MeanUint8SimpleAxisTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 1, 1, 3, 2 };
     const unsigned int outputShape[] = { 1, 1, 2 };
@@ -5649,10 +6126,13 @@
     std::vector<uint8_t> input({ 1, 1, 2, 2, 3, 3 });
     std::vector<uint8_t> output({ 2, 2 });
 
-    return MeanTestHelper<uint8_t, 4, 3>(workloadFactory, inputShape, input, { 2 }, false, outputShape, output);
+    return MeanTestHelper<uint8_t, 4, 3>(
+        workloadFactory, memoryManager, inputShape, input, { 2 }, false, outputShape, output);
 }
 
-LayerTestResult<uint8_t, 4> MeanUint8KeepDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> MeanUint8KeepDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 1, 1, 3, 2 };
     const unsigned int outputShape[] = { 1, 1, 1, 2 };
@@ -5660,10 +6140,13 @@
     std::vector<uint8_t> input({ 1, 1, 2, 2, 3, 3 });
     std::vector<uint8_t> output({ 2, 2 });
 
-    return MeanTestHelper<uint8_t, 4, 4>(workloadFactory, inputShape, input, { 2 }, true, outputShape, output);
+    return MeanTestHelper<uint8_t, 4, 4>(
+        workloadFactory, memoryManager, inputShape, input, { 2 }, true, outputShape, output);
 }
 
-LayerTestResult<uint8_t, 4> MeanUint8MultipleDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> MeanUint8MultipleDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 2, 3, 1, 2 };
     const unsigned int outputShape[] = { 1, 3, 1, 1 };
@@ -5671,10 +6154,13 @@
     std::vector<uint8_t> input({ 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6 });
     std::vector<uint8_t> output({ 1, 3, 5 });
 
-    return MeanTestHelper<uint8_t, 4, 4>(workloadFactory, inputShape, input, { 0, 3 }, true, outputShape, output);
+    return MeanTestHelper<uint8_t, 4, 4>(
+        workloadFactory, memoryManager, inputShape, input, { 0, 3 }, true, outputShape, output);
 }
 
-LayerTestResult<uint8_t, 1> MeanVtsUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 1> MeanVtsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 4, 3, 2 };
     const unsigned int outputShape[] = { 2 };
@@ -5683,11 +6169,14 @@
                                  24 });
     std::vector<uint8_t> output({ 12, 13 });
 
-    return MeanTestHelper<uint8_t, 3, 1>(workloadFactory, inputShape, input, { 0, 1 }, false, outputShape,
+    return MeanTestHelper<uint8_t, 3, 1>(workloadFactory, memoryManager,
+                                         inputShape, input, { 0, 1 }, false, outputShape,
                                          output, 0.8f, 5);
 }
 
-LayerTestResult<float, 1> MeanFloatSimpleTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 1> MeanFloatSimpleTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 3, 2 };
     const unsigned int outputShape[] = { 1 };
@@ -5695,10 +6184,13 @@
     std::vector<float> input({ 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f });
     std::vector<float> output({ 2.0f });
 
-    return MeanTestHelper<float, 2, 1>(workloadFactory, inputShape, input, {}, false, outputShape, output);
+    return MeanTestHelper<float, 2, 1>(
+        workloadFactory, memoryManager, inputShape, input, {}, false, outputShape, output);
 }
 
-LayerTestResult<float, 3> MeanFloatSimpleAxisTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> MeanFloatSimpleAxisTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 2, 3, 1, 2 };
     const unsigned int outputShape[] = { 3, 1, 2 };
@@ -5706,10 +6198,13 @@
     std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f });
     std::vector<float> output({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f });
 
-    return MeanTestHelper<float, 4, 3>(workloadFactory, inputShape, input, { 0 }, false, outputShape, output);
+    return MeanTestHelper<float, 4, 3>(
+        workloadFactory, memoryManager, inputShape, input, { 0 }, false, outputShape, output);
 }
 
-LayerTestResult<float, 4> MeanFloatKeepDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> MeanFloatKeepDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 1, 1, 3, 2 };
     const unsigned int outputShape[] = { 1, 1, 1, 2 };
@@ -5717,10 +6212,13 @@
     std::vector<float> input({ 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f });
     std::vector<float> output({ 2.0f, 2.0f });
 
-    return MeanTestHelper<float, 4, 4>(workloadFactory, inputShape, input, { 2 }, true, outputShape, output);
+    return MeanTestHelper<float, 4, 4>(
+        workloadFactory, memoryManager, inputShape, input, { 2 }, true, outputShape, output);
 }
 
-LayerTestResult<float, 4> MeanFloatMultipleDimsTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> MeanFloatMultipleDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 2, 3, 1, 2 };
     const unsigned int outputShape[] = { 1, 3, 1, 1 };
@@ -5728,10 +6226,13 @@
     std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f });
     std::vector<float> output({ 1.5f, 3.5f, 5.5f });
 
-    return MeanTestHelper<float, 4, 4>(workloadFactory, inputShape, input, { 0, 3 }, true, outputShape, output);
+    return MeanTestHelper<float, 4, 4>(
+        workloadFactory, memoryManager, inputShape, input, { 0, 3 }, true, outputShape, output);
 }
 
-LayerTestResult<float, 1> MeanVtsFloat1Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 1> MeanVtsFloat1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 4, 3, 2 };
     const unsigned int outputShape[] = { 2 };
@@ -5740,10 +6241,13 @@
                                15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f });
     std::vector<float> output({ 12.0f, 13.0f });
 
-    return MeanTestHelper<float, 3, 1>(workloadFactory, inputShape, input, { 0, 1 }, false, outputShape, output);
+    return MeanTestHelper<float, 3, 1>(
+        workloadFactory, memoryManager, inputShape, input, { 0, 1 }, false, outputShape, output);
 }
 
-LayerTestResult<float, 3> MeanVtsFloat2Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> MeanVtsFloat2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 4, 3, 2 };
     const unsigned int outputShape[] = { 1, 3, 1 };
@@ -5752,10 +6256,13 @@
                                15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f });
     std::vector<float> output({ 10.5f, 12.5f, 14.5f });
 
-    return MeanTestHelper<float, 3, 3>(workloadFactory, inputShape, input, { 0, 2 }, true, outputShape, output);
+    return MeanTestHelper<float, 3, 3>(
+        workloadFactory, memoryManager, inputShape, input, { 0, 2 }, true, outputShape, output);
 }
 
-LayerTestResult<float, 3> MeanVtsFloat3Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 3> MeanVtsFloat3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = { 1, 2, 2, 1 };
     const unsigned int outputShape[] = { 1, 2, 1 };
@@ -5763,10 +6270,13 @@
     std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f });
     std::vector<float> output({ 1.5f, 3.5f });
 
-    return MeanTestHelper<float, 4, 3>(workloadFactory, inputShape, input, { 2 }, false, outputShape, output);
+    return MeanTestHelper<float, 4, 3>(
+        workloadFactory, memoryManager, inputShape, input, { 2 }, false, outputShape, output);
 }
 
-LayerTestResult<float, 4> AdditionAfterMaxPoolTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> AdditionAfterMaxPoolTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     // Create Initial Tensor
     // 1, 2, 3
@@ -5867,99 +6377,133 @@
     return addRet;
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdSimpleFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdSimpleFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdSimpleTest<float>(workloadFactory);
+    return SpaceToBatchNdSimpleTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiChannelsTest<float>(workloadFactory);
+    return SpaceToBatchNdMultiChannelsTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdMultiBlockFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdMultiBlockFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiBlockTest<float>(workloadFactory);
+    return SpaceToBatchNdMultiBlockTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdPaddingFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdPaddingFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdPaddingTest<float>(workloadFactory);
+    return SpaceToBatchNdPaddingTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdSimpleTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdSimpleTest<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiChannelsTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdMultiChannelsTest<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiBlockTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdMultiBlockTest<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdPaddingTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdPaddingTest<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdSimpleNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdSimpleNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdSimpleNHWCTest<float>(workloadFactory);
+    return SpaceToBatchNdSimpleNHWCTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiChannelsNHWCTest<float>(workloadFactory);
+    return SpaceToBatchNdMultiChannelsNHWCTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdMultiBlockNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdMultiBlockNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiBlockNHWCTest<float>(workloadFactory);
+    return SpaceToBatchNdMultiBlockNHWCTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<float, 4> SpaceToBatchNdPaddingNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SpaceToBatchNdPaddingNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdPaddingNHWCTest<float>(workloadFactory);
+    return SpaceToBatchNdPaddingNHWCTest<float>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdSimpleNHWCTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdSimpleNHWCTest<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiChannelsNHWCTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdMultiChannelsNHWCTest<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiBlockNHWCTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdMultiBlockNHWCTest<uint8_t>(workloadFactory, memoryManager);
 }
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdPaddingNHWCTest<uint8_t>(workloadFactory);
+    return SpaceToBatchNdPaddingNHWCTest<uint8_t>(workloadFactory, memoryManager);
 }
 
 namespace {
 
 template<typename T, std::size_t InputDim, std::size_t OutputDim>
-LayerTestResult<T, OutputDim> BatchToSpaceNdHelper(armnn::IWorkloadFactory &workloadFactory,
-                                                   const armnn::DataLayout& dataLayout,
-                                                   const unsigned int *inputShape,
-                                                   const std::vector<T> &inputData,
-                                                   const std::vector<unsigned int> &blockShape,
-                                                   const std::vector<std::pair<unsigned int, unsigned int>> &crops,
-                                                   const unsigned int *outputShape,
-                                                   const std::vector<T> &outputData,
-                                                   float scale = 1.0f,
-                                                   int32_t offset = 0)
+LayerTestResult<T, OutputDim> BatchToSpaceNdHelper(
+    armnn::IWorkloadFactory &workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayout& dataLayout,
+    const unsigned int *inputShape,
+    const std::vector<T> &inputData,
+    const std::vector<unsigned int> &blockShape,
+    const std::vector<std::pair<unsigned int, unsigned int>> &crops,
+    const unsigned int *outputShape,
+    const std::vector<T> &outputData,
+    float scale = 1.0f,
+    int32_t offset = 0)
   {
     auto dataType = (std::is_same<T, uint8_t>::value ? armnn::DataType::QuantisedAsymm8 : armnn::DataType::Float32);
 
@@ -6004,7 +6548,9 @@
 
 } // anonymous namespace
 
-LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test1(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test1(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = {4, 2, 2, 1};
     const unsigned int outputShape[] = {1, 4, 4, 1 };
@@ -6045,11 +6591,14 @@
     std::vector<unsigned int> blockShape {2, 2};
     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
 
-    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, armnn::DataLayout::NHWC, inputShape, input, blockShape,
+    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, memoryManager,
+            armnn::DataLayout::NHWC, inputShape, input, blockShape,
             crops, outputShape, expectedOutput);
 }
 
-LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test2(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test2(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = {4, 1, 1, 1};
     const unsigned int outputShape[] = {1, 2, 2, 1};
@@ -6065,11 +6614,14 @@
     std::vector<unsigned int> blockShape({2, 2});
     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
 
-    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, armnn::DataLayout::NHWC, inputShape, input, blockShape,
-                                             crops, outputShape, expectedOutput);
+    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, memoryManager,
+        armnn::DataLayout::NHWC, inputShape, input, blockShape,
+        crops, outputShape, expectedOutput);
 }
 
-LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test3(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test3(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = {4, 1, 1, 3};
     const unsigned int outputShape[] = {1, 2, 2, 3};
@@ -6081,11 +6633,14 @@
     std::vector<unsigned int> blockShape({2, 2});
     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
 
-    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, armnn::DataLayout::NHWC, inputShape, input, blockShape,
-                                             crops, outputShape, expectedOutput);
+    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, memoryManager,
+        armnn::DataLayout::NHWC, inputShape, input, blockShape,
+        crops, outputShape, expectedOutput);
 }
 
-LayerTestResult<float, 4> BatchToSpaceNdNchwFloat32Test1(armnn::IWorkloadFactory &workloadFactory)
+LayerTestResult<float, 4> BatchToSpaceNdNchwFloat32Test1(
+    armnn::IWorkloadFactory &workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = {4, 3, 1, 1};
     const unsigned int outputShape[] = {1, 3, 2, 2};
@@ -6110,12 +6665,15 @@
     std::vector<unsigned int> blockShape({2, 2});
     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
 
-    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, armnn::DataLayout::NCHW, inputShape, input, blockShape,
-                                             crops, outputShape, expectedOutput);
+    return BatchToSpaceNdHelper<float, 4, 4>(workloadFactory, memoryManager,
+        armnn::DataLayout::NCHW, inputShape, input, blockShape,
+        crops, outputShape, expectedOutput);
 }
 
 
-LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcUintTest1(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcUintTest1(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const unsigned int inputShape[] = {4, 2, 2, 1};
     const unsigned int outputShape[] = {1, 4, 4, 1};
@@ -6126,6 +6684,7 @@
     std::vector<unsigned int> blockShape({2, 2});
     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
 
-    return BatchToSpaceNdHelper<uint8_t, 4, 4>(workloadFactory, armnn::DataLayout::NHWC, inputShape, input, blockShape,
-                                               crops, outputShape, expectedOutput);
-}
\ No newline at end of file
+    return BatchToSpaceNdHelper<uint8_t, 4, 4>(workloadFactory, memoryManager,
+        armnn::DataLayout::NHWC, inputShape, input, blockShape,
+        crops, outputShape, expectedOutput);
+}
diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp
index c38d84f..7734e5e 100644
--- a/src/backends/backendsCommon/test/LayerTests.hpp
+++ b/src/backends/backendsCommon/test/LayerTests.hpp
@@ -9,6 +9,9 @@
 
 #include <Half.hpp>
 
+#include <backendsCommon/IBackendInternal.hpp>
+#include <backendsCommon/IMemoryManager.hpp>
+
 #include <boost/multi_array.hpp>
 #include <boost/assert.hpp>
 
@@ -51,393 +54,948 @@
     bool supported;
 };
 
-LayerTestResult<float, 4> SimpleConvolution2d3x5Test(armnn::IWorkloadFactory& workloadFactory,
-                                                     bool biasEnabled,
-                                                     const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 4> SimpleConvolution2d3x5Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
 
-LayerTestResult<float, 4> SimpleConvolution2d3x3Test(armnn::IWorkloadFactory& workloadFactory,
-                                                     bool biasEnabled,
-                                                     const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 4> SimpleConvolution2d3x3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
 
-LayerTestResult<float, 4> SimpleConvolution2d3x3NhwcTest(armnn::IWorkloadFactory& workloadFactory,
-                                                         bool biasEnabled);
+LayerTestResult<float, 4> SimpleConvolution2d3x3NhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled);
 
 LayerTestResult<float, 4>
-Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest(armnn::IWorkloadFactory& workloadFactory,
-                                                           const armnn::DataLayoutIndexed& layout);
-LayerTestResult<float, 4> Convolution2dAsymmetricPaddingTest(armnn::IWorkloadFactory& workloadFactory,
-                                                             const armnn::DataLayoutIndexed& layout);
+Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout);
 
+LayerTestResult<float, 4> Convolution2dAsymmetricPaddingTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout);
 
-LayerTestResult<float,   4> Convolution1dTest(armnn::IWorkloadFactory& workloadFactory,
-                                              bool biasEnabled);
-LayerTestResult<uint8_t, 4> Convolution1dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                   bool biasEnabled);
+LayerTestResult<float,   4> Convolution1dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled);
 
-LayerTestResult<float, 4> DepthwiseConvolution2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                     bool biasEnabled,
-                                                     const armnn::DataLayoutIndexed& layout);
+LayerTestResult<uint8_t, 4> Convolution1dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled);
 
-LayerTestResult<float, 4> DepthwiseConvolution2dDepthNhwcTest(armnn::IWorkloadFactory& workloadFactory,
-                                                              bool biasEnabled);
+LayerTestResult<float, 4> DepthwiseConvolution2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
 
-LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul1Test(armnn::IWorkloadFactory& workloadFactory,
-                                                              bool biasEnabled,
-                                                              const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 4> DepthwiseConvolution2dDepthNhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled);
 
-LayerTestResult<float, 4> DepthwiseConvolution2dAsymmetricTest(armnn::IWorkloadFactory& workloadFactory,
-                                                               bool biasEnabled,
-                                                               const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
 
-LayerTestResult<float,   4> SimpleMaxPooling2dSize2x2Stride2x2Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                   bool forceNoPadding);
-LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                        bool forceNoPadding);
-LayerTestResult<float,   4> SimpleMaxPooling2dSize3x3Stride2x4Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                   bool forceNoPadding);
-LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                        bool forceNoPadding );
-LayerTestResult<float,   4> IgnorePaddingSimpleMaxPooling2dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> IgnorePaddingMaxPooling2dSize3Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> DepthwiseConvolution2dAsymmetricTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
 
-LayerTestResult<float,   4> SimpleMaxPooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                   const armnn::DataLayoutIndexed& dataLayout);
-LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                        const armnn::DataLayoutIndexed& dataLayout);
+LayerTestResult<float,   4> SimpleMaxPooling2dSize2x2Stride2x2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding);
 
-LayerTestResult<float,   4> SimpleAveragePooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                       const armnn::DataLayoutIndexed& dataLayout);
-LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            const armnn::DataLayoutIndexed& dataLayout);
+LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding);
 
-LayerTestResult<float,   4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                              bool forceNoPadding);
-LayerTestResult<float,   4> IgnorePaddingSimpleAveragePooling2dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4>   IgnorePaddingSimpleAveragePooling2dNoPaddingTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float,   4> SimpleMaxPooling2dSize3x3Stride2x4Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding);
+
+LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding );
+
+LayerTestResult<float,   4> IgnorePaddingSimpleMaxPooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float,   4> IgnorePaddingMaxPooling2dSize3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float,   4> SimpleMaxPooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+LayerTestResult<float,   4> SimpleAveragePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+LayerTestResult<float,   4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding);
+
+LayerTestResult<float,   4> IgnorePaddingSimpleAveragePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4>   IgnorePaddingSimpleAveragePooling2dNoPaddingTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test(
-    armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> IgnorePaddingAveragePooling2dSize3Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(armnn::IWorkloadFactory& workloadFactory);
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float,   4> SimpleL2Pooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                  const armnn::DataLayoutIndexed& dataLayout);
-LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                       const armnn::DataLayoutIndexed& dataLayout);
+LayerTestResult<float,   4> IgnorePaddingAveragePooling2dSize3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float,   4> L2Pooling2dSize3Stride1Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> L2Pooling2dSize3Stride3Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> L2Pooling2dSize3Stride4Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> L2Pooling2dSize7Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> L2Pooling2dSize9Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> LargeTensorsAveragePooling2dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float,   4> IgnorePaddingSimpleL2Pooling2dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,   4> IgnorePaddingL2Pooling2dSize3Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float,   4> SimpleL2Pooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
 
-LayerTestResult<float,   4> AsymmetricNonSquarePooling2dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
 
-LayerTestResult<float, 4> ComparePooling2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                               armnn::IWorkloadFactory& refWorkloadFactory,
-                                               armnn::PoolingAlgorithm  poolingType);
-LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                      armnn::IWorkloadFactory& refWorkloadFactory,
-                                                      armnn::PoolingAlgorithm  poolingType);
+LayerTestResult<float,   4> L2Pooling2dSize3Stride1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> ConstantLinearActivationTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> SimpleNormalizationAcrossTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SimpleNormalizationWithinTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float,4> SimpleNormalizationAcrossNhwcTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float,   4> L2Pooling2dSize3Stride3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 2> SimpleSoftmaxTest(armnn::IWorkloadFactory& workloadFactory, float beta);
-LayerTestResult<uint8_t, 2> SimpleSoftmaxUint8Test(armnn::IWorkloadFactory& workloadFactory, float beta);
+LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> SimpleSigmoidTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float,   4> L2Pooling2dSize3Stride4Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> SimpleReshapeFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SimpleReshapeUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> SimpleFloorTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float,   4> L2Pooling2dSize7Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 1> Concatenation1dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 2> Concatenation2dDim0Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 2> Concatenation2dDim1Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 2> Concatenation2dDim0DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 2> Concatenation2dDim1DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> Concatenation3dDim0Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> Concatenation3dDim1Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> Concatenation3dDim2Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> Concatenation3dDim0DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> Concatenation3dDim1DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> Concatenation3dDim2DiffInputDimsTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> SimpleSigmoidUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float,   4> L2Pooling2dSize9Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> CompareConvolution2dTest(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float,   4> LargeTensorsAveragePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float,   4> IgnorePaddingSimpleL2Pooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float,   4> IgnorePaddingL2Pooling2dSize3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float,   4> AsymmetricNonSquarePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> ComparePooling2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::PoolingAlgorithm  poolingType);
+
+LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::PoolingAlgorithm  poolingType);
+
+LayerTestResult<float, 4> ConstantLinearActivationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SimpleNormalizationAcrossTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SimpleNormalizationWithinTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float,4> SimpleNormalizationAcrossNhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> SimpleSoftmaxTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float beta);
+
+LayerTestResult<uint8_t, 2> SimpleSoftmaxUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float beta);
+
+LayerTestResult<float, 4> SimpleSigmoidTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SimpleReshapeFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SimpleReshapeUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SimpleFloorTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 1> Concatenation1dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> Concatenation2dDim0Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> Concatenation2dDim1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> Concatenation2dDim0DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> Concatenation2dDim1DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> Concatenation3dDim0Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> Concatenation3dDim1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> Concatenation3dDim2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> Concatenation3dDim0DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> Concatenation3dDim1DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> Concatenation3dDim2DiffInputDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SimpleSigmoidUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> CompareConvolution2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::IWorkloadFactory& refWorkloadFactory);
 
 template<typename T>
-LayerTestResult<T, 4> CompareDepthwiseConvolution2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                        armnn::IWorkloadFactory& refWorkloadFactory,
-                                                        const armnn::DataLayoutIndexed& layout);
+LayerTestResult<T, 4> CompareDepthwiseConvolution2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    const armnn::DataLayoutIndexed& layout);
 
-LayerTestResult<float, 4> CompareNormalizationTest(armnn::IWorkloadFactory& workloadFactory,
-                                                   armnn::IWorkloadFactory& refWorkloadFactory,
-                                                   armnn::NormalizationAlgorithmChannel normChannel,
-                                                   armnn::NormalizationAlgorithmMethod normMethod);
+LayerTestResult<float, 4> CompareNormalizationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::NormalizationAlgorithmChannel normChannel,
+    armnn::NormalizationAlgorithmMethod normMethod);
 
-LayerTestResult<float, 2> CompareSoftmaxTest(armnn::IWorkloadFactory& workloadFactory,
-    armnn::IWorkloadFactory& refWorkloadFactory, float beta);
-
-LayerTestResult<float, 2> FullyConnectedFloat32Test(armnn::IWorkloadFactory& workloadFactory,
-                                             bool                     biasEnabled,
-                                             bool                     transposeWeights);
-
-std::vector<LayerTestResult<float, 3>> SplitterTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> CopyViaSplitterTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 3> MergerTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> AdditionTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> AdditionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> AdditionBroadcastTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> CompareAdditionTest(armnn::IWorkloadFactory& workloadFactory,
-                                              armnn::IWorkloadFactory& refWorkloadFactory);
-
-LayerTestResult<float, 4> SubtractionTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SubtractionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SubtractionBroadcastTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> CompareActivationTest(armnn::IWorkloadFactory&  workloadFactory,
-                                                armnn::IWorkloadFactory&  refWorkloadFactory,
-                                                armnn::ActivationFunction f,
-                                                unsigned int batchSize);
-
-LayerTestResult<float, 4> DivisionTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> DivisionByZeroTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> DivisionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> MultiplicationTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> CompareMultiplicationTest(armnn::IWorkloadFactory& workloadFactory,
-                                             armnn::IWorkloadFactory& refWorkloadFactory);
-
-LayerTestResult<float, 4> BatchNormTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> BatchNormNhwcTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> CompareBatchNormTest(armnn::IWorkloadFactory& workloadFactory,
-                                        armnn::IWorkloadFactory& refWorkloadFactory);
-
-LayerTestResult<float, 4> BoundedReLuUpperAndLowerBoundTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperAndLowerBoundTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> BoundedReLuUpperBoundOnlyTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperBoundOnlyTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> CompareBoundedReLuTest(armnn::IWorkloadFactory& workloadFactory,
-                                                 armnn::IWorkloadFactory& refWorkloadFactory,
-                                                 float upperBound,
-                                                 float lowerBound);
-
-// Tests that the output should be identical to the input when the output dimensions match the input ones.
-LayerTestResult<float, 4> ResizeBilinearNopTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& dataLayout);
-
-// Tests the behaviour of the resize bilinear operation when rescaling a 2x2 image into a 1x1 image.
-LayerTestResult<float, 4> SimpleResizeBilinearTest(armnn::IWorkloadFactory& workloadFactory,
-                                                   const armnn::DataLayoutIndexed& dataLayout);
-
-// Tests the resize bilinear for minification of a square input matrix (also: input dimensions are a
-// multiple of output dimensions).
-LayerTestResult<float, 4> ResizeBilinearSqMinTest(armnn::IWorkloadFactory& workloadFactory,
-                                                  const armnn::DataLayoutIndexed& dataLayout);
-
-// Tests the resize bilinear for minification (output dimensions smaller than input dimensions).
-LayerTestResult<float, 4> ResizeBilinearMinTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& dataLayout);
-
-// Tests the resize bilinear for magnification (output dimensions bigger than input dimensions).
-LayerTestResult<float, 4> ResizeBilinearMagTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& dataLayout);
-
-LayerTestResult<float, 4> BatchNormTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> BatchNormNhwcTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 2> FakeQuantizationTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<float, 4> L2Normalization1dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout);
-LayerTestResult<float, 4> L2Normalization2dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout);
-LayerTestResult<float, 4> L2Normalization3dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout);
-LayerTestResult<float, 4> L2Normalization4dTest(armnn::IWorkloadFactory& workloadFactory,
-                                                const armnn::DataLayoutIndexed& layout);
-
-LayerTestResult<float, 4> ConstantTest(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<uint8_t, 4> ConstantTestUint8(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(armnn::IWorkloadFactory& workloadFactory, float upperBound);
-LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(armnn::IWorkloadFactory& workloadFactory,
-    float upperBound,
-    float lowerBound);
-
-LayerTestResult<uint8_t, 2> FullyConnectedUint8Test(armnn::IWorkloadFactory& workloadFactory, bool biasEnabled);
-
-std::vector<LayerTestResult<uint8_t, 3>> SplitterUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> CopyViaSplitterUint8Test(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<uint8_t, 3> MergerUint8Test(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<uint8_t, 4> AdditionUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> AdditionBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> AdditionBroadcastUint8Test(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<uint8_t, 4> SubtractionUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SubtractionBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SubtractionBroadcastUint8Test(armnn::IWorkloadFactory& workloadFactory);
-
-LayerTestResult<uint8_t, 4> CompareActivationUint8Test(armnn::IWorkloadFactory&  workloadFactory,
-                                                       armnn::IWorkloadFactory&  refWorkloadFactory,
-                                                       armnn::ActivationFunction f);
-
-LayerTestResult<uint8_t, 2> CompareSoftmaxUint8Test(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<float, 2> CompareSoftmaxTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::IWorkloadFactory& refWorkloadFactory,
     float beta);
 
-LayerTestResult<uint8_t, 4> MultiplicationUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> MultiplicationBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> MultiplicationBroadcast1DVectorUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 2> FullyConnectedFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    bool transposeWeights);
 
-LayerTestResult<uint8_t, 4> DivisionUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> DivisionBroadcast1ElementUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> DivisionBroadcast1DVectorUint8Test(armnn::IWorkloadFactory& workloadFactory);
+std::vector<LayerTestResult<float, 3>> SplitterTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> SimpleConvolution2d3x5Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            bool                     biasEnabled,
-                                                            const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 3> CopyViaSplitterTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> SimpleConvolution2d3x3Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            bool                     biasEnabled,
-                                                            const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 3> MergerTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> DepthwiseConvolution2dUint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                            bool                     biasEnabled,
-                                                            const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 4> AdditionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> DepthwiseConvolution2dDepthMul1Uint8Test(armnn::IWorkloadFactory& workloadFactory,
-                                                                     bool biasEnabled,
-                                                                     const armnn::DataLayoutIndexed& layout);
+LayerTestResult<float, 4> AdditionBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> ConstantLinearActivationUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> AdditionBroadcastTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> ResizeBilinearNopUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SimpleResizeBilinearUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> ResizeBilinearSqMinUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> ResizeBilinearMinUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> ResizeBilinearMagUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> CompareAdditionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory);
 
-LayerTestResult<uint8_t, 4> BatchNormUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> BatchNormUint8NhwcTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> SubtractionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> ConstantUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> SubtractionBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 1> Concatenation1dUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 2> Concatenation2dDim0Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 2> Concatenation2dDim1Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 2> Concatenation2dDim0DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 2> Concatenation2dDim1DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> Concatenation3dDim0Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> Concatenation3dDim1Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> Concatenation3dDim2Uint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> Concatenation3dDim0DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> Concatenation3dDim1DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> Concatenation3dDim2DiffInputDimsUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> SubtractionBroadcastTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
+LayerTestResult<float, 4> CompareActivationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::ActivationFunction f,
+    unsigned int batchSize);
 
-LayerTestResult<float, 2> FullyConnectedLargeTest(armnn::IWorkloadFactory& workloadFactory,
-                                                  bool transposeWeights);
-LayerTestResult<float, 4> SimplePermuteFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SimplePermuteUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> DivisionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 2> PadUint82dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> PadUint83dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> PadUint84dTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> DivisionByZeroTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 2> PadFloat322dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> PadFloat323dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> PadFloat324dTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> DivisionBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> PermuteFloat32ValueSet1Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> PermuteFloat32ValueSet2Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> PermuteFloat32ValueSet3Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 2> LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest
-        (armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 2>
-        LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 2>
-LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> MultiplicationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> SimpleConvertFp16ToFp32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<armnn::Half, 4> SimpleConvertFp32ToFp16Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
+LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 1> MeanUint8SimpleTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 3> MeanUint8SimpleAxisTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> MeanUint8KeepDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> MeanUint8MultipleDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 1> MeanVtsUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 1> MeanFloatSimpleTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> MeanFloatSimpleAxisTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> MeanFloatKeepDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> MeanFloatMultipleDimsTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 1> MeanVtsFloat1Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> MeanVtsFloat2Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> MeanVtsFloat3Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> CompareMultiplicationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory);
 
-LayerTestResult<float, 4> AdditionAfterMaxPoolTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> BatchNormTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> SpaceToBatchNdSimpleFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SpaceToBatchNdMultiBlockFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SpaceToBatchNdPaddingFloat32Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> BatchNormNhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> CompareBatchNormTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory);
 
-LayerTestResult<float, 4> SpaceToBatchNdSimpleNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SpaceToBatchNdMultiBlockNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> SpaceToBatchNdPaddingNHWCFloat32Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> BoundedReLuUpperAndLowerBoundTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingNHWCUint8Test(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperAndLowerBoundTest(
+    armnn::IWorkloadFactory& workloadFactor,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManagery);
 
-LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test1(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test2(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test3(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> BoundedReLuUpperBoundOnlyTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> BatchToSpaceNdNchwFloat32Test1(armnn::IWorkloadFactory &workloadFactory);
+LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperBoundOnlyTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcUintTest1(armnn::IWorkloadFactory &workloadFactory);
\ No newline at end of file
+LayerTestResult<float, 4> CompareBoundedReLuTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    float upperBound,
+    float lowerBound);
+
+// Tests that the output should be identical to the input when the output dimensions match the input ones.
+LayerTestResult<float, 4> ResizeBilinearNopTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+// Tests the behaviour of the resize bilinear operation when rescaling a 2x2 image into a 1x1 image.
+LayerTestResult<float, 4> SimpleResizeBilinearTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+// Tests the resize bilinear for minification of a square input matrix (also: input dimensions are a
+// multiple of output dimensions).
+LayerTestResult<float, 4> ResizeBilinearSqMinTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+// Tests the resize bilinear for minification (output dimensions smaller than input dimensions).
+LayerTestResult<float, 4> ResizeBilinearMinTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+// Tests the resize bilinear for magnification (output dimensions bigger than input dimensions).
+LayerTestResult<float, 4> ResizeBilinearMagTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout);
+
+LayerTestResult<float, 4> BatchNormTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> BatchNormNhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> FakeQuantizationTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> L2Normalization1dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<float, 4> L2Normalization2dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<float, 4> L2Normalization3dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<float, 4> L2Normalization4dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<float, 4> ConstantTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> ConstantTestUint8(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float upperBound);
+
+LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float upperBound,
+    float lowerBound);
+
+LayerTestResult<uint8_t, 2> FullyConnectedUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled);
+
+std::vector<LayerTestResult<uint8_t, 3>> SplitterUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> CopyViaSplitterUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> MergerUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> AdditionUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> AdditionBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> AdditionBroadcastUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SubtractionUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SubtractionBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SubtractionBroadcastUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> CompareActivationUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::ActivationFunction f);
+
+LayerTestResult<uint8_t, 2> CompareSoftmaxUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    float beta);
+
+LayerTestResult<uint8_t, 4> MultiplicationUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> MultiplicationBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> MultiplicationBroadcast1DVectorUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> DivisionUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> DivisionBroadcast1ElementUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> DivisionBroadcast1DVectorUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SimpleConvolution2d3x5Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<uint8_t, 4> SimpleConvolution2d3x3Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<uint8_t, 4> DepthwiseConvolution2dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<uint8_t, 4> DepthwiseConvolution2dDepthMul1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool biasEnabled,
+    const armnn::DataLayoutIndexed& layout);
+
+LayerTestResult<uint8_t, 4> ConstantLinearActivationUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> ResizeBilinearNopUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SimpleResizeBilinearUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> ResizeBilinearSqMinUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> ResizeBilinearMinUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> ResizeBilinearMagUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> BatchNormUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> BatchNormUint8NhwcTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> ConstantUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 1> Concatenation1dUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 2> Concatenation2dDim0Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 2> Concatenation2dDim1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 2> Concatenation2dDim0DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 2> Concatenation2dDim1DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> Concatenation3dDim0Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> Concatenation3dDim1Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> Concatenation3dDim2Uint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> Concatenation3dDim0DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> Concatenation3dDim1DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> Concatenation3dDim2DiffInputDimsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> FullyConnectedLargeTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool transposeWeights);
+
+LayerTestResult<float, 4> SimplePermuteFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SimplePermuteUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 2> PadUint82dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> PadUint83dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> PadUint84dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> PadFloat322dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> PadFloat323dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> PadFloat324dTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> PermuteFloat32ValueSet1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> PermuteFloat32ValueSet2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> PermuteFloat32ValueSet3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SimpleConvertFp16ToFp32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<armnn::Half, 4> SimpleConvertFp32ToFp16Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 1> MeanUint8SimpleTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 3> MeanUint8SimpleAxisTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> MeanUint8KeepDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> MeanUint8MultipleDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 1> MeanVtsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 1> MeanFloatSimpleTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> MeanFloatSimpleAxisTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> MeanFloatKeepDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> MeanFloatMultipleDimsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 1> MeanVtsFloat1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> MeanVtsFloat2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 3> MeanVtsFloat3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> AdditionAfterMaxPoolTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdSimpleFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdMultiBlockFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdPaddingFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdSimpleNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdMultiBlockNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> SpaceToBatchNdPaddingNHWCFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingNHWCUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test1(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test2(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> BatchToSpaceNdNhwcFloat32Test3(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<float, 4> BatchToSpaceNdNchwFloat32Test1(
+    armnn::IWorkloadFactory &workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcUintTest1(
+    armnn::IWorkloadFactory &workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
diff --git a/src/backends/backendsCommon/test/LstmTestImpl.hpp b/src/backends/backendsCommon/test/LstmTestImpl.hpp
index bb567e7..dfe24aa 100644
--- a/src/backends/backendsCommon/test/LstmTestImpl.hpp
+++ b/src/backends/backendsCommon/test/LstmTestImpl.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "QuantizeHelper.hpp"
+#include "WorkloadTestUtils.hpp"
 
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
@@ -15,9 +16,11 @@
 #include <backendsCommon/CpuTensorHandle.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
-LayerTestResult<float, 2> LstmNoCifgNoPeepholeNoProjectionTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                                   const boost::multi_array<float, 2>& input,
-                                                                   const boost::multi_array<float, 2>& outputExpected)
+LayerTestResult<float, 2> LstmNoCifgNoPeepholeNoProjectionTestImpl(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const boost::multi_array<float, 2>& input,
+        const boost::multi_array<float, 2>& outputExpected)
 {
     unsigned int batchSize = boost::numeric_cast<unsigned int>(input.shape()[0]);
     unsigned int inputSize = boost::numeric_cast<unsigned int>(input.shape()[1]);
@@ -219,10 +222,12 @@
 
 
 LayerTestResult<float, 2>
-LstmLayerFloat32NoCifgWithPeepholeWithProjectionTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                             const boost::multi_array<float, 2>& input,
-                                             const boost::multi_array<float, 2>& outputExpected) {
-
+LstmLayerFloat32NoCifgWithPeepholeWithProjectionTestImpl(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const boost::multi_array<float, 2>& input,
+        const boost::multi_array<float, 2>& outputExpected)
+{
     unsigned int batchSize = 2;
     unsigned int outputSize = 16;
     unsigned int inputSize = 5;
@@ -928,9 +933,11 @@
 }
 
 
-LayerTestResult<float, 2> LstmLayerWithCifgWithPeepholeNoProjectionTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                                   const boost::multi_array<float, 2>& input,
-                                                                   const boost::multi_array<float, 2>& outputExpected)
+LayerTestResult<float, 2> LstmLayerWithCifgWithPeepholeNoProjectionTestImpl(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const boost::multi_array<float, 2>& input,
+        const boost::multi_array<float, 2>& outputExpected)
 {
     bool cifgEnabled = true;
     bool peepholeEnabled = true;
diff --git a/src/backends/backendsCommon/test/NormTestImpl.hpp b/src/backends/backendsCommon/test/NormTestImpl.hpp
index 16893eb..38a0053 100644
--- a/src/backends/backendsCommon/test/NormTestImpl.hpp
+++ b/src/backends/backendsCommon/test/NormTestImpl.hpp
@@ -3,16 +3,21 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "WorkloadTestUtils.hpp"
+
 #include <armnn/Exceptions.hpp>
 #include <armnn/LayerSupport.hpp>
-#include "armnn/Types.hpp"
+#include <armnn/Types.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
-LayerTestResult<float,4> SimpleNormalizationTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                     armnn::NormalizationAlgorithmChannel normChannel,
-                                                     armnn::NormalizationAlgorithmMethod normMethod)
+LayerTestResult<float,4> SimpleNormalizationTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::NormalizationAlgorithmChannel normChannel,
+    armnn::NormalizationAlgorithmMethod normMethod)
 {
     const unsigned int inputHeight = 2;
     const unsigned int inputWidth = 2;
@@ -73,9 +78,7 @@
 
     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
 
@@ -153,9 +156,11 @@
     return ret;
 }
 
-LayerTestResult<float,4> SimpleNormalizationNhwcTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                         armnn::NormalizationAlgorithmChannel normChannel,
-                                                         armnn::NormalizationAlgorithmMethod normMethod)
+LayerTestResult<float,4> SimpleNormalizationNhwcTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::NormalizationAlgorithmChannel normChannel,
+    armnn::NormalizationAlgorithmMethod normMethod)
 {
     const unsigned int inputHeight = 2;
     const unsigned int inputWidth = 2;
@@ -216,9 +221,7 @@
 
     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
 
@@ -254,10 +257,12 @@
     return ret;
 }
 
-LayerTestResult<float,4> CompareNormalizationTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                                      armnn::IWorkloadFactory& refWorkloadFactory,
-                                                      armnn::NormalizationAlgorithmChannel normChannel,
-                                                      armnn::NormalizationAlgorithmMethod normMethod)
+LayerTestResult<float,4> CompareNormalizationTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::NormalizationAlgorithmChannel normChannel,
+    armnn::NormalizationAlgorithmMethod normMethod)
 {
     constexpr unsigned int inputNum = 5;
     constexpr unsigned int inputChannels = 3;
@@ -332,9 +337,7 @@
     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
     CopyDataToITensorHandle(inputHandleRef.get(), &input[0][0][0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     workloadRef->Execute();
 
diff --git a/src/backends/backendsCommon/test/PermuteTestImpl.hpp b/src/backends/backendsCommon/test/PermuteTestImpl.hpp
index 529f9d3..c8120a4 100644
--- a/src/backends/backendsCommon/test/PermuteTestImpl.hpp
+++ b/src/backends/backendsCommon/test/PermuteTestImpl.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "QuantizeHelper.hpp"
+#include "WorkloadTestUtils.hpp"
 
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
@@ -13,11 +14,13 @@
 #include <test/TensorHelpers.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
 template<typename T>
 LayerTestResult<T, 4> SimplePermuteTestImpl(
         armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
         armnn::PermuteDescriptor descriptor,
         armnn::TensorInfo inputTensorInfo,
         armnn::TensorInfo outputTensorInfo,
@@ -52,7 +55,9 @@
     return ret;
 }
 
-LayerTestResult<float, 4> SimplePermuteFloat32TestCommon(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SimplePermuteFloat32TestCommon(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -81,11 +86,14 @@
                     3.0f, 7.0f, 4.0f, 8.0f
             });
 
-    return SimplePermuteTestImpl<float>(workloadFactory, descriptor, inputTensorInfo,
+    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
+                                        descriptor, inputTensorInfo,
                                         outputTensorInfo, input, outputExpected);
 }
 
-LayerTestResult<uint8_t, 4> SimplePermuteUint8TestCommon(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SimplePermuteUint8TestCommon(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -116,12 +124,15 @@
                     3, 7, 4, 8
             });
 
-    return SimplePermuteTestImpl<uint8_t>(workloadFactory, descriptor, inputTensorInfo,
+    return SimplePermuteTestImpl<uint8_t>(workloadFactory, memoryManager,
+                                          descriptor, inputTensorInfo,
                                           outputTensorInfo, input, outputExpected);
 }
 
 LayerTestResult<float, 4>
-PermuteFloat32ValueSet1TestCommon(armnn::IWorkloadFactory& workloadFactory)
+PermuteFloat32ValueSet1TestCommon(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -150,12 +161,15 @@
                     3.0f, 13.0f, 23.0f, 33.0f,
             });
 
-    return SimplePermuteTestImpl<float>(workloadFactory, descriptor, inputTensorInfo,
+    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
+                                        descriptor, inputTensorInfo,
                                         outputTensorInfo, input, outputExpected);
 }
 
 LayerTestResult<float, 4>
-PermuteFloat32ValueSet2TestCommon(armnn::IWorkloadFactory& workloadFactory)
+PermuteFloat32ValueSet2TestCommon(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -184,12 +198,15 @@
                 31.0f, 32.0f, 33.0f,
             });
 
-    return SimplePermuteTestImpl<float>(workloadFactory, descriptor, inputTensorInfo,
+    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
+                                        descriptor, inputTensorInfo,
                                         outputTensorInfo, input, outputExpected);
 }
 
 LayerTestResult<float, 4>
-PermuteFloat32ValueSet3TestCommon(armnn::IWorkloadFactory& workloadFactory)
+PermuteFloat32ValueSet3TestCommon(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -220,6 +237,7 @@
                 3.0f, 13.0f, 23.0f, 33.0f, 43.0f, 53.0f,
             });
 
-    return SimplePermuteTestImpl<float>(workloadFactory, descriptor, inputTensorInfo,
+    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
+                                        descriptor, inputTensorInfo,
                                         outputTensorInfo, input, outputExpected);
 }
diff --git a/src/backends/backendsCommon/test/Pooling2dTestImpl.hpp b/src/backends/backendsCommon/test/Pooling2dTestImpl.hpp
index ded45ab..2e851fa 100644
--- a/src/backends/backendsCommon/test/Pooling2dTestImpl.hpp
+++ b/src/backends/backendsCommon/test/Pooling2dTestImpl.hpp
@@ -4,6 +4,8 @@
 //
 #pragma once
 
+#include "WorkloadTestUtils.hpp"
+
 #include "QuantizeHelper.hpp"
 
 #include <armnn/ArmNN.hpp>
@@ -11,6 +13,7 @@
 #include <Permute.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 #include <backendsCommon/WorkloadInfo.hpp>
 
@@ -22,12 +25,14 @@
 #include <string>
 
 template<typename T>
-LayerTestResult<T, 4> SimplePooling2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
-                                              armnn::Pooling2dDescriptor descriptor,
-                                              float qScale,
-                                              int32_t qOffset,
-                                              const boost::multi_array<T, 4>& input,
-                                              const boost::multi_array<T, 4>& outputExpected)
+LayerTestResult<T, 4> SimplePooling2dTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::Pooling2dDescriptor descriptor,
+    float qScale,
+    int32_t qOffset,
+    const boost::multi_array<T, 4>& input,
+    const boost::multi_array<T, 4>& outputExpected)
 {
     const armnn::DataLayoutIndexed dataLayout = descriptor.m_DataLayout;
     auto heightIndex = dataLayout.GetHeightIndex();
@@ -109,10 +114,12 @@
 //   batch size:   2
 //
 template<typename T>
-LayerTestResult<T, 4> SimpleMaxPooling2dSize3x3Stride2x4TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                                   bool forceNoPadding,
-                                                                   float qScale = 1.0f,
-                                                                   int32_t qOffset = 0)
+LayerTestResult<T, 4> SimpleMaxPooling2dSize3x3Stride2x4TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
@@ -225,14 +232,17 @@
         }));
     }
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleMaxPooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                   const armnn::DataLayoutIndexed& dataLayout = armnn::DataLayout::NCHW,
-                                                   float qScale = 1.0f,
-                                                   int32_t qOffset = 0)
+LayerTestResult<T, 4> SimpleMaxPooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::DataLayoutIndexed& dataLayout = armnn::DataLayout::NCHW,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
@@ -291,14 +301,17 @@
 
     auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputData);
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleAveragePooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                       armnn::DataLayoutIndexed dataLayout = armnn::DataLayout::NCHW,
-                                                       float qScale = 1.0f,
-                                                       int32_t qOffset = 0)
+LayerTestResult<T, 4> SimpleAveragePooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::DataLayoutIndexed dataLayout = armnn::DataLayout::NCHW,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
@@ -357,13 +370,16 @@
 
     auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputData);
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> LargeTensorsAveragePooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                             float qScale = 1.0f,
-                                                             int32_t qOffset = 0)
+LayerTestResult<T, 4> LargeTensorsAveragePooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
@@ -405,14 +421,17 @@
 
     auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputVec);
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> SimpleL2Pooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                  armnn::DataLayoutIndexed dataLayout = armnn::DataLayout::NCHW,
-                                                  float qScale = 1.0f,
-                                                  int32_t qOffset = 0)
+LayerTestResult<T, 4> SimpleL2Pooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::DataLayoutIndexed dataLayout = armnn::DataLayout::NCHW,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -462,13 +481,16 @@
 
     auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputData);
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> L2Pooling2dSize3Stride1TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                        float qScale = 1.0f,
-                                                        int32_t qOffset = 0)
+LayerTestResult<T, 4> L2Pooling2dSize3Stride1TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -492,13 +514,16 @@
             3.0f, 3.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> L2Pooling2dSize3Stride3TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                        float qScale = 1.0f,
-                                                        int32_t qOffset = 0)
+LayerTestResult<T, 4> L2Pooling2dSize3Stride3TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -528,13 +553,16 @@
             3.0f, 3.0f, 3.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> L2Pooling2dSize3Stride4TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                        float qScale = 1.0f,
-                                                        int32_t qOffset = 0)
+LayerTestResult<T, 4> L2Pooling2dSize3Stride4TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -561,13 +589,16 @@
             3.0f, 3.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> L2Pooling2dSize7TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                 float qScale = 1.0f,
-                                                 int32_t qOffset = 0)
+LayerTestResult<T, 4> L2Pooling2dSize7TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -593,13 +624,16 @@
             3.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> L2Pooling2dSize9TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                 float qScale = 1.0f,
-                                                 int32_t qOffset = 0)
+LayerTestResult<T, 4> L2Pooling2dSize9TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -627,13 +661,16 @@
             3.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> AsymmetricNonSquarePooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                             float qScale = 1.0f,
-                                                             int32_t qOffset = 0)
+LayerTestResult<T, 4> AsymmetricNonSquarePooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::TensorInfo inputTensorInfo({ 1, 1, 1, 3 }, armnn::GetDataType<T>());
     armnn::TensorInfo outputTensorInfo({ 1, 1, 2, 2 }, armnn::GetDataType<T>());
@@ -663,15 +700,18 @@
             0.0f, 3.0f, 0.0f, 3.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> ComparePooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                 armnn::IWorkloadFactory& refWorkloadFactory,
-                                                 armnn::PoolingAlgorithm poolingType,
-                                                 float qScale = 1.0f,
-                                                 int32_t qOffset = 0)
+LayerTestResult<T, 4> ComparePooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::IWorkloadFactory& refWorkloadFactory,
+    armnn::PoolingAlgorithm poolingType,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     const unsigned int inputWidth = 16;
     const unsigned int inputHeight = 32;
@@ -777,10 +817,12 @@
 //   batch size:   1
 //
 template<typename T>
-LayerTestResult<T, 4> SimpleMaxPooling2dSize2x2Stride2x2TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                                   bool forceNoPadding,
-                                                                   float qScale = 1.0f,
-                                                                   int32_t qOffset = 0)
+LayerTestResult<T, 4> SimpleMaxPooling2dSize2x2Stride2x2TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    bool forceNoPadding,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
@@ -792,8 +834,11 @@
     descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
     descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
 
+
     unsigned int inputWidth = 4;
+
     unsigned int inputHeight = 4;
+
     unsigned int outputWidth =
         (inputWidth + descriptor.m_PadLeft + descriptor.m_PadRight + descriptor.m_StrideX - descriptor.m_PoolWidth) /
         descriptor.m_StrideX;
@@ -841,7 +886,8 @@
         forceNoPadding ? QuantizedVector<T>(qScale, qOffset, expectedOutputDataNoPadding) :
                          QuantizedVector<T>(qScale, qOffset, expectedOutputDataWithPadding));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 //
@@ -856,6 +902,7 @@
 template<typename T>
 LayerTestResult<T, 4> IgnorePaddingAveragePooling2dSize3x2Stride2x2TestCommon(
         armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
         bool forceNoPadding,
         float qScale = 1.0f,
         int32_t qOffset = 0)
@@ -917,14 +964,17 @@
         forceNoPadding ? QuantizedVector<T>(qScale, qOffset, expectedOutputDataNoPadding) :
                          QuantizedVector<T>(qScale, qOffset, expectedOutputDataWithPadding));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 
 template<typename T>
-LayerTestResult<T, 4> IgnorePaddingSimpleMaxPooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                            float qScale = 1.0f,
-                                                            int32_t qOffset = 0)
+LayerTestResult<T, 4> IgnorePaddingSimpleMaxPooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
@@ -963,13 +1013,16 @@
              1.0f,  2.0f, -4.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> IgnorePaddingMaxPooling2dSize3TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                            float qScale = 1.0f,
-                                                            int32_t qOffset = 0)
+LayerTestResult<T, 4> IgnorePaddingMaxPooling2dSize3TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
@@ -1009,13 +1062,16 @@
              2.0f,  2.0f,  2.0f, -3.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> IgnorePaddingSimpleAveragePooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                                 float qScale = 1.0f,
-                                                                 int32_t qOffset = 0)
+LayerTestResult<T, 4> IgnorePaddingSimpleAveragePooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
@@ -1054,13 +1110,16 @@
             3.0f,  13.0f,  10.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                                 float qScale = 1.0f,
-                                                                 int32_t qOffset = 0)
+LayerTestResult<T, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
@@ -1099,13 +1158,16 @@
             2.0f, 3.5f
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> IgnorePaddingAveragePooling2dSize3TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                                float qScale = 1.0f,
-                                                                int32_t qOffset = 0)
+LayerTestResult<T, 4> IgnorePaddingAveragePooling2dSize3TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
@@ -1145,13 +1207,16 @@
              9.0f,  11.0f,  12.0f, 7.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> IgnorePaddingSimpleL2Pooling2dTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                            float qScale = 1.0f,
-                                                            int32_t qOffset = 0)
+LayerTestResult<T, 4> IgnorePaddingSimpleL2Pooling2dTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -1190,13 +1255,16 @@
                8.0f,     1.4142f,   4.0f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
 
 template<typename T>
-LayerTestResult<T, 4> IgnorePaddingL2Pooling2dSize3TestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                           float qScale = 1.0f,
-                                                           int32_t qOffset = 0)
+LayerTestResult<T, 4> IgnorePaddingL2Pooling2dSize3TestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 1.0f,
+    int32_t qOffset = 0)
 {
     armnn::Pooling2dDescriptor descriptor;
     descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
@@ -1236,5 +1304,6 @@
             1.0540f, 1.7638f, 2.5385f, 2.3570f,
         }));
 
-    return SimplePooling2dTestImpl<T>(workloadFactory, descriptor, qScale, qOffset, input, outputExpected);
+    return SimplePooling2dTestImpl<T>(
+        workloadFactory, memoryManager, descriptor, qScale, qOffset, input, outputExpected);
 }
diff --git a/src/backends/backendsCommon/test/ReshapeTestImpl.hpp b/src/backends/backendsCommon/test/ReshapeTestImpl.hpp
index fee992d..49918c5 100644
--- a/src/backends/backendsCommon/test/ReshapeTestImpl.hpp
+++ b/src/backends/backendsCommon/test/ReshapeTestImpl.hpp
@@ -5,12 +5,14 @@
 #pragma once
 
 #include "QuantizeHelper.hpp"
+#include "WorkloadTestUtils.hpp"
 
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
 #include <armnn/TypesUtils.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
 #include <test/TensorHelpers.hpp>
@@ -18,6 +20,7 @@
 template<typename T>
 LayerTestResult<T, 4> SimpleReshapeTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::TensorInfo inputTensorInfo,
     armnn::TensorInfo outputTensorInfo,
     const std::vector<T>& inputData,
@@ -50,7 +53,9 @@
     return ret;
 }
 
-LayerTestResult<float, 4> SimpleReshapeFloat32Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SimpleReshapeFloat32Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -91,10 +96,13 @@
         27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f, 33.0f, 34.0f, 35.0f,
     });
 
-    return SimpleReshapeTestImpl<float>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected);
+    return SimpleReshapeTestImpl<float>(
+        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected);
 }
 
-LayerTestResult<float, 4> SimpleFloorTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<float, 4> SimpleFloorTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     const armnn::TensorInfo inputTensorInfo({1, 3, 2, 3}, armnn::DataType::Float32);
     const armnn::TensorInfo outputTensorInfo(inputTensorInfo);
@@ -130,7 +138,9 @@
     return ret;
 }
 
-LayerTestResult<uint8_t, 4> SimpleReshapeUint8Test(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<uint8_t, 4> SimpleReshapeUint8Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -173,5 +183,6 @@
         27, 28, 29, 30, 31, 32, 33, 34, 35,
     });
 
-    return SimpleReshapeTestImpl<uint8_t>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected);
+    return SimpleReshapeTestImpl<uint8_t>(
+        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected);
 }
diff --git a/src/backends/backendsCommon/test/SoftmaxTestImpl.hpp b/src/backends/backendsCommon/test/SoftmaxTestImpl.hpp
index 2a23986..97199e3 100644
--- a/src/backends/backendsCommon/test/SoftmaxTestImpl.hpp
+++ b/src/backends/backendsCommon/test/SoftmaxTestImpl.hpp
@@ -5,12 +5,14 @@
 #pragma once
 
 #include "QuantizeHelper.hpp"
+#include "WorkloadTestUtils.hpp"
 
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
 #include <armnn/TypesUtils.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
 #include <test/TensorHelpers.hpp>
@@ -18,7 +20,10 @@
 #include <algorithm>
 
 template<typename T>
-LayerTestResult<T, 2> SimpleSoftmaxTestImpl(armnn::IWorkloadFactory& workloadFactory, float beta)
+LayerTestResult<T, 2> SimpleSoftmaxTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float beta)
 {
     using std::exp;
 
@@ -62,9 +67,7 @@
     outputHandle->Allocate();
     CopyDataToITensorHandle(inputHandle.get(), &input[0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     CopyDataFromITensorHandle(&ret.output[0][0], outputHandle.get());
 
@@ -85,7 +88,9 @@
 }
 
 template<typename T>
-LayerTestResult<T, 2> CompareSoftmaxTestImpl(armnn::IWorkloadFactory& workloadFactory,
+LayerTestResult<T, 2> CompareSoftmaxTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::IWorkloadFactory& refWorkloadFactory,
     float beta)
 {
@@ -142,9 +147,7 @@
     CopyDataToITensorHandle(inputHandle.get(), &input[0][0]);
     CopyDataToITensorHandle(inputHandleRef.get(), &input[0][0]);
 
-    workloadFactory.Acquire();
-    workload->Execute();
-    workloadFactory.Release();
+    ExecuteWorkload(*workload, memoryManager);
 
     workloadRef->Execute();
 
diff --git a/src/backends/backendsCommon/test/SpaceToBatchNdTestImpl.hpp b/src/backends/backendsCommon/test/SpaceToBatchNdTestImpl.hpp
index 5dd21bf..a467cd3 100644
--- a/src/backends/backendsCommon/test/SpaceToBatchNdTestImpl.hpp
+++ b/src/backends/backendsCommon/test/SpaceToBatchNdTestImpl.hpp
@@ -4,18 +4,22 @@
 //
 #pragma once
 
+#include "WorkloadTestUtils.hpp"
+
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
 #include <armnn/TypesUtils.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
 #include <test/TensorHelpers.hpp>
 
 template<typename T>
 LayerTestResult<T, 4> SpaceToBatchNdTestImpl(
-    const armnn::IWorkloadFactory& workloadFactory,
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::TensorInfo& inputTensorInfo,
     armnn::TensorInfo& outputTensorInfo,
     std::vector<float>& inputData,
@@ -74,8 +78,10 @@
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdSimpleTest(armnn::IWorkloadFactory& workloadFactory,
-                                               armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
+LayerTestResult<T, 4> SpaceToBatchNdSimpleTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -101,12 +107,15 @@
         1.0f, 2.0f, 3.0f, 4.0f
     });
 
-    return SpaceToBatchNdTestImpl<T>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
+    return SpaceToBatchNdTestImpl<T>(
+        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdMultiChannelsTest(armnn::IWorkloadFactory& workloadFactory,
-                                                      armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
+LayerTestResult<T, 4> SpaceToBatchNdMultiChannelsTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -137,12 +146,15 @@
         10.0f, 11.0f, 12.0f
     });
 
-    return SpaceToBatchNdTestImpl<T>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
+    return SpaceToBatchNdTestImpl<T>(
+        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdMultiBlockTest(armnn::IWorkloadFactory& workloadFactory,
-                                                   armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
+LayerTestResult<T, 4> SpaceToBatchNdMultiBlockTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -174,12 +186,15 @@
         6.0f, 8.0f, 14.0f, 16.0f
     });
 
-    return SpaceToBatchNdTestImpl<T>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
+    return SpaceToBatchNdTestImpl<T>(
+        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdPaddingTest(armnn::IWorkloadFactory& workloadFactory,
-                                                armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
+LayerTestResult<T, 4> SpaceToBatchNdPaddingTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -215,29 +230,38 @@
         0.0f, 14.0f, 16.0f
     });
 
-    return SpaceToBatchNdTestImpl<T>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
+    return SpaceToBatchNdTestImpl<T>(
+        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdSimpleNHWCTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<T, 4> SpaceToBatchNdSimpleNHWCTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdSimpleTest<T>(workloadFactory, armnn::DataLayout::NHWC);
+    return SpaceToBatchNdSimpleTest<T>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdMultiChannelsNHWCTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<T, 4> SpaceToBatchNdMultiChannelsNHWCTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiChannelsTest<T>(workloadFactory, armnn::DataLayout::NHWC);
+    return SpaceToBatchNdMultiChannelsTest<T>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdMultiBlockNHWCTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<T, 4> SpaceToBatchNdMultiBlockNHWCTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdMultiBlockTest<T>(workloadFactory, armnn::DataLayout::NHWC);
+    return SpaceToBatchNdMultiBlockTest<T>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 }
 
 template <typename T>
-LayerTestResult<T, 4> SpaceToBatchNdPaddingNHWCTest(armnn::IWorkloadFactory& workloadFactory)
+LayerTestResult<T, 4> SpaceToBatchNdPaddingNHWCTest(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
-    return SpaceToBatchNdPaddingTest<T>(workloadFactory, armnn::DataLayout::NHWC);
+    return SpaceToBatchNdPaddingTest<T>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 }
diff --git a/src/backends/backendsCommon/test/SplitterTestImpl.hpp b/src/backends/backendsCommon/test/SplitterTestImpl.hpp
index 677950c..e88356c 100644
--- a/src/backends/backendsCommon/test/SplitterTestImpl.hpp
+++ b/src/backends/backendsCommon/test/SplitterTestImpl.hpp
@@ -4,19 +4,24 @@
 //
 #pragma once
 
+#include "WorkloadTestUtils.hpp"
+
 #include <armnn/ArmNN.hpp>
 #include <armnn/Tensor.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 #include <backendsCommon/test/QuantizeHelper.hpp>
 
 #include <test/TensorHelpers.hpp>
 
 template<typename T>
-std::vector<LayerTestResult<T,3>> SplitterTestCommon(armnn::IWorkloadFactory& workloadFactory,
-                                                     float qScale = 0.0f,
-                                                     int32_t qOffset = 0)
+std::vector<LayerTestResult<T,3>> SplitterTestCommon(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale = 0.0f,
+    int32_t qOffset = 0)
 {
     unsigned int inputWidth = 5;
     unsigned int inputHeight = 6;
@@ -214,7 +219,7 @@
     CopyDataFromITensorHandle(&ret1.output[0][0][0], outputHandle1.get());
     CopyDataFromITensorHandle(&ret2.output[0][0][0], outputHandle2.get());
 
-//    // Do the second split.
+    // Do the second split.
     armnn::SplitterQueueDescriptor data2;
     armnn::WorkloadInfo info2;
     AddInputToWorkload(data2, info2, outputTensorInfo2, outputHandle2.get());
@@ -229,7 +234,7 @@
     outputHandle3->Allocate();
     outputHandle4->Allocate();
 
-    workload2->Execute();
+    ExecuteWorkload(*workload2, memoryManager);
 
     CopyDataFromITensorHandle(&ret3.output[0][0][0], outputHandle3.get());
     CopyDataFromITensorHandle(&ret4.output[0][0][0], outputHandle4.get());
@@ -241,7 +246,10 @@
 
 
 template <typename T>
-LayerTestResult<T, 3> CopyViaSplitterTestImpl(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
+LayerTestResult<T, 3> CopyViaSplitterTestImpl(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    float qScale, int32_t qOffset)
 {
     const armnn::TensorInfo tensorInfo({ 3, 6, 5 }, armnn::GetDataType<T>());
     auto input = MakeTensor<T, 3>(tensorInfo, QuantizedVector<T>(qScale, qOffset,
diff --git a/src/backends/backendsCommon/test/WorkloadTestUtils.hpp b/src/backends/backendsCommon/test/WorkloadTestUtils.hpp
index 05f6dde..d03c5a9 100644
--- a/src/backends/backendsCommon/test/WorkloadTestUtils.hpp
+++ b/src/backends/backendsCommon/test/WorkloadTestUtils.hpp
@@ -6,12 +6,18 @@
 
 #include <armnn/Tensor.hpp>
 
+#include <backendsCommon/IBackendInternal.hpp>
+#include <backendsCommon/IMemoryManager.hpp>
+#include <backendsCommon/Workload.hpp>
 #include <backendsCommon/WorkloadInfo.hpp>
 
 namespace armnn
 {
 class ITensorHandle;
-}
+} // namespace armnn
+
+namespace
+{
 
 template <typename QueueDescriptor>
 void AddInputToWorkload(QueueDescriptor& descriptor,
@@ -53,4 +59,28 @@
 {
     descriptor.m_Outputs[index] = tensorHandle;
     info.m_OutputTensorInfos[index] = tensorInfo;
-}
\ No newline at end of file
+}
+
+inline void ExecuteWorkload(armnn::IWorkload& workload,
+                            const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                            bool memoryManagementRequested = true)
+{
+    const bool manageMemory = memoryManager && memoryManagementRequested;
+
+    // Acquire working memory (if needed)
+    if (manageMemory)
+    {
+        memoryManager->Acquire();
+    }
+
+    // Execute the workload
+    workload.Execute();
+
+    // Release working memory (if needed)
+    if (manageMemory)
+    {
+        memoryManager->Release();
+    }
+}
+
+} // anonymous namespace
diff --git a/src/backends/cl/ClWorkloadFactory.cpp b/src/backends/cl/ClWorkloadFactory.cpp
index 5679549..1f11200 100644
--- a/src/backends/cl/ClWorkloadFactory.cpp
+++ b/src/backends/cl/ClWorkloadFactory.cpp
@@ -5,26 +5,22 @@
 #include "ClWorkloadFactory.hpp"
 #include "ClBackendId.hpp"
 
+#include <Layer.hpp>
+
 #include <armnn/Exceptions.hpp>
 #include <armnn/Utils.hpp>
 
-#include <string>
 #include <backendsCommon/CpuTensorHandle.hpp>
-#include <Layer.hpp>
-
-#ifdef ARMCOMPUTECL_ENABLED
-#include <arm_compute/core/CL/CLKernelLibrary.h>
-#include <arm_compute/runtime/CL/CLBufferAllocator.h>
-#include <arm_compute/runtime/CL/CLScheduler.h>
-
+#include <backendsCommon/MakeWorkloadHelper.hpp>
 #include <backendsCommon/MemCopyWorkload.hpp>
 
 #include <cl/ClTensorHandle.hpp>
 #include <cl/workloads/ClWorkloads.hpp>
 #include <cl/workloads/ClWorkloadUtils.hpp>
-#endif
 
-#include <backendsCommon/MakeWorkloadHelper.hpp>
+#include <arm_compute/core/CL/CLKernelLibrary.h>
+#include <arm_compute/runtime/CL/CLBufferAllocator.h>
+#include <arm_compute/runtime/CL/CLScheduler.h>
 
 #include <boost/polymorphic_cast.hpp>
 #include <boost/format.hpp>
@@ -50,8 +46,6 @@
     return s_Id;
 }
 
-#ifdef ARMCOMPUTECL_ENABLED
-
 template <typename FloatWorkload, typename Uint8Workload, typename QueueDescriptorType, typename... Args>
 std::unique_ptr<IWorkload> ClWorkloadFactory::MakeWorkload(const QueueDescriptorType& descriptor,
                                                            const WorkloadInfo& info,
@@ -320,232 +314,4 @@
     return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
 }
 
-void ClWorkloadFactory::Release()
-{
-    m_MemoryManager->Release();
-}
-
-void ClWorkloadFactory::Acquire()
-{
-    m_MemoryManager->Acquire();
-}
-
-#else // #if ARMCOMPUTECL_ENABLED
-
-std::unique_ptr<ITensorHandle> ClWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<ITensorHandle> ClWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                                     DataLayout dataLayout) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<ITensorHandle> ClWorkloadFactory::CreateSubTensorHandle(ITensorHandle&      parent,
-                                                                        TensorShape const&   subTensorShape,
-                                                                        unsigned int const* subTensorOrigin) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor,
-                                                          const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateOutput(const OutputQueueDescriptor& descriptor,
-                                                           const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateActivation(const ActivationQueueDescriptor& descriptor,
-                                                               const WorkloadInfo&              info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
-                                                            const WorkloadInfo&           info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor,
-                                                             const WorkloadInfo&            info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateMerger(const MergerQueueDescriptor& descriptor,
-                                                           const WorkloadInfo&          info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFullyConnected(const FullyConnectedQueueDescriptor& descriptor,
-                                                                   const WorkloadInfo&                  info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreatePermute(const PermuteQueueDescriptor& descriptor,
-                                                                   const WorkloadInfo&           info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreatePooling2d(const Pooling2dQueueDescriptor& descriptor,
-                                                              const WorkloadInfo&           info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor,
-                                                                  const WorkloadInfo&               info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateDepthwiseConvolution2d(
-    const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateNormalization(const NormalizationQueueDescriptor& descriptor,
-                                                                  const WorkloadInfo&                 info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor,
-                                                             const WorkloadInfo&            info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateMultiplication(const MultiplicationQueueDescriptor& descriptor,
-                                                                   const WorkloadInfo&                  info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateBatchNormalization(
-    const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateMemCopy(const MemCopyQueueDescriptor& descriptor,
-                                                            const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateResizeBilinear(const ResizeBilinearQueueDescriptor& descriptor,
-                                                                   const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFakeQuantization(const FakeQuantizationQueueDescriptor& descriptor,
-                                                                     const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateConstant(const ConstantQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateReshape(const ReshapeQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateLstm(const LstmQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateConvertFp16ToFp32(
-    const ConvertFp16ToFp32QueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateConvertFp32ToFp16(
-    const ConvertFp32ToFp16QueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateDivision(const DivisionQueueDescriptor& descriptor,
-                                                             const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSubtraction(const SubtractionQueueDescriptor& descriptor,
-                                                                const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateMean(const MeanQueueDescriptor& descriptor,
-                                                         const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreatePad(const PadQueueDescriptor& descriptor,
-                                                        const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> ClWorkloadFactory::CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
-                                                        const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-void ClWorkloadFactory::Release()
-{
-}
-
-void ClWorkloadFactory::Acquire()
-{
-}
-
-#endif // #if ARMCOMPUTECL_ENABLED
-
 } // namespace armnn
diff --git a/src/backends/cl/ClWorkloadFactory.hpp b/src/backends/cl/ClWorkloadFactory.hpp
index cb715e1..d37a31f 100644
--- a/src/backends/cl/ClWorkloadFactory.hpp
+++ b/src/backends/cl/ClWorkloadFactory.hpp
@@ -129,10 +129,6 @@
     virtual std::unique_ptr<IWorkload> CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
                                                             const WorkloadInfo& info) const override;
 
-    virtual void Release() override;
-
-    virtual void Acquire() override;
-
 private:
     template<typename FloatWorkload, typename Uint8Workload, typename QueueDescriptorType, typename... Args>
     static std::unique_ptr<IWorkload> MakeWorkload(const QueueDescriptorType& descriptor,
diff --git a/src/backends/cl/test/ClCreateWorkloadTests.cpp b/src/backends/cl/test/ClCreateWorkloadTests.cpp
index 978b3bc..b243ca8 100644
--- a/src/backends/cl/test/ClCreateWorkloadTests.cpp
+++ b/src/backends/cl/test/ClCreateWorkloadTests.cpp
@@ -27,7 +27,8 @@
 static void ClCreateActivationWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
 
@@ -57,7 +58,9 @@
 static void ClCreateArithmethicWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateArithmeticWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
 
     // Checks that inputs/outputs are as we expect them (see definition of CreateArithmeticWorkloadTest).
@@ -146,7 +149,8 @@
 static void ClCreateBatchNormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
                     (factory, graph, dataLayout);
@@ -195,7 +199,9 @@
 BOOST_AUTO_TEST_CASE(CreateConvertFp16ToFp32Workload)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
 
     ConvertFp16ToFp32QueueDescriptor queueDescriptor = workload->GetData();
@@ -211,7 +217,9 @@
 BOOST_AUTO_TEST_CASE(CreateConvertFp32ToFp16Workload)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
 
     ConvertFp32ToFp16QueueDescriptor queueDescriptor = workload->GetData();
@@ -228,7 +236,9 @@
 static void ClConvolution2dWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory,
                                                                                        graph,
                                                                                        dataLayout);
@@ -270,7 +280,8 @@
 static void ClDepthwiseConvolutionWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateDepthwiseConvolution2dWorkloadTest<DepthwiseConvolutionWorkloadType, DataType>
                     (factory, graph, dataLayout);
@@ -300,7 +311,9 @@
 static void ClDirectConvolution2dWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory, graph);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateDirectConvolution2dWorkloadTest).
@@ -330,7 +343,9 @@
 static void ClCreateFullyConnectedWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload =
         CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
 
@@ -357,7 +372,9 @@
 static void ClNormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
 
     // Checks that inputs/outputs are as we expect them (see definition of CreateNormalizationWorkloadTest).
@@ -398,7 +415,8 @@
 static void ClPooling2dWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreatePooling2dWorkloadTest<ClPooling2dWorkload, DataType>(factory, graph, dataLayout);
 
@@ -440,7 +458,8 @@
 static void ClCreateReshapeWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateReshapeWorkloadTest<ClReshapeWorkload, DataType>(factory, graph);
 
@@ -472,7 +491,8 @@
 static void ClSoftmaxWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
 
@@ -500,7 +520,8 @@
 static void ClSplitterWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateSplitterWorkloadTest<ClSplitterWorkload, DataType>(factory, graph);
 
@@ -541,7 +562,8 @@
     // of the merger.
 
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workloads =
         CreateSplitterMergerWorkloadTest<ClSplitterWorkload, ClMergerWorkload, DataType>
@@ -590,7 +612,9 @@
     // We create a splitter with two outputs. That each of those outputs is used by two different activation layers.
 
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     std::unique_ptr<ClSplitterWorkload> wlSplitter;
     std::unique_ptr<ClActivationWorkload> wlActiv0_0;
     std::unique_ptr<ClActivationWorkload> wlActiv0_1;
@@ -625,7 +649,9 @@
 
 BOOST_AUTO_TEST_CASE(CreateMemCopyWorkloadsCl)
 {
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     CreateMemCopyWorkloads<IClTensorHandle>(factory);
 }
 
@@ -633,7 +659,9 @@
 static void ClL2NormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload =
             CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
 
@@ -677,7 +705,9 @@
 static void ClCreateLstmWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
 
     LstmQueueDescriptor queueDescriptor = workload->GetData();
@@ -696,7 +726,8 @@
 static void ClResizeBilinearWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateResizeBilinearWorkloadTest<ResizeBilinearWorkloadType, DataType>(factory, graph, dataLayout);
 
@@ -742,7 +773,9 @@
 static void ClMeanWorkloadTest()
 {
     Graph graph;
-    ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
 
     // Checks that inputs/outputs are as we expect them (see definition of CreateMeanWorkloadTest).
diff --git a/src/backends/cl/test/ClLayerSupportTests.cpp b/src/backends/cl/test/ClLayerSupportTests.cpp
index 2218d82..acfd8c3 100644
--- a/src/backends/cl/test/ClLayerSupportTests.cpp
+++ b/src/backends/cl/test/ClLayerSupportTests.cpp
@@ -23,19 +23,22 @@
 
 BOOST_FIXTURE_TEST_CASE(IsLayerSupportedFloat16Cl, ClContextControlFixture)
 {
-    armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    armnn::ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
     IsLayerSupportedTests<armnn::ClWorkloadFactory, armnn::DataType::Float16>(&factory);
 }
 
 BOOST_FIXTURE_TEST_CASE(IsLayerSupportedFloat32Cl, ClContextControlFixture)
 {
-    armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    armnn::ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
     IsLayerSupportedTests<armnn::ClWorkloadFactory, armnn::DataType::Float32>(&factory);
 }
 
 BOOST_FIXTURE_TEST_CASE(IsLayerSupportedUint8Cl, ClContextControlFixture)
 {
-    armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory();
+    armnn::ClWorkloadFactory factory =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
     IsLayerSupportedTests<armnn::ClWorkloadFactory, armnn::DataType::QuantisedAsymm8>(&factory);
 }
 
diff --git a/src/backends/cl/test/ClOptimizedNetworkTests.cpp b/src/backends/cl/test/ClOptimizedNetworkTests.cpp
index 7e32147..f8c1a32 100644
--- a/src/backends/cl/test/ClOptimizedNetworkTests.cpp
+++ b/src/backends/cl/test/ClOptimizedNetworkTests.cpp
@@ -34,7 +34,8 @@
     armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec());
     BOOST_CHECK(optNet);
     // validate workloads
-    armnn::ClWorkloadFactory fact = ClWorkloadFactoryHelper::GetFactory();
+    armnn::ClWorkloadFactory fact =
+        ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
     for (auto&& layer : static_cast<armnn::OptimizedNetwork*>(optNet.get())->GetGraph())
     {
         BOOST_CHECK(layer->GetBackendId() == armnn::Compute::GpuAcc);
diff --git a/src/backends/cl/test/ClWorkloadFactoryHelper.hpp b/src/backends/cl/test/ClWorkloadFactoryHelper.hpp
index 7b60b8a..777bc84 100644
--- a/src/backends/cl/test/ClWorkloadFactoryHelper.hpp
+++ b/src/backends/cl/test/ClWorkloadFactoryHelper.hpp
@@ -9,10 +9,9 @@
 #include <backendsCommon/IMemoryManager.hpp>
 #include <backendsCommon/test/WorkloadFactoryHelper.hpp>
 
+#include <cl/ClBackend.hpp>
 #include <cl/ClWorkloadFactory.hpp>
 
-#include <arm_compute/runtime/CL/CLBufferAllocator.h>
-
 #include <boost/polymorphic_pointer_cast.hpp>
 
 namespace
@@ -21,11 +20,15 @@
 template<>
 struct WorkloadFactoryHelper<armnn::ClWorkloadFactory>
 {
-    static armnn::ClWorkloadFactory GetFactory()
+    static armnn::IBackendInternal::IMemoryManagerSharedPtr GetMemoryManager()
     {
-        armnn::IBackendInternal::IMemoryManagerSharedPtr memoryManager =
-            std::make_shared<armnn::ClMemoryManager>(std::make_unique<arm_compute::CLBufferAllocator>());
+        armnn::ClBackend backend;
+        return backend.CreateMemoryManager();
+    }
 
+    static armnn::ClWorkloadFactory GetFactory(
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    {
         return armnn::ClWorkloadFactory(boost::polymorphic_pointer_downcast<armnn::ClMemoryManager>(memoryManager));
     }
 };
diff --git a/src/backends/cl/test/OpenClTimerTest.cpp b/src/backends/cl/test/OpenClTimerTest.cpp
index 6e55be6..6f44cc4 100644
--- a/src/backends/cl/test/OpenClTimerTest.cpp
+++ b/src/backends/cl/test/OpenClTimerTest.cpp
@@ -44,7 +44,8 @@
 
 BOOST_AUTO_TEST_CASE(OpenClTimerBatchNorm)
 {
-    ClWorkloadFactory  workloadFactory = ClWorkloadFactoryHelper::GetFactory();
+    auto memoryManager = ClWorkloadFactoryHelper::GetMemoryManager();
+    ClWorkloadFactory workloadFactory = ClWorkloadFactoryHelper::GetFactory(memoryManager);
 
     const unsigned int width    = 2;
     const unsigned int height   = 3;
diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index 6584447..ef90240 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -282,14 +282,4 @@
     return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
 }
 
-void NeonWorkloadFactory::Release()
-{
-    m_MemoryManager->Release();
-}
-
-void NeonWorkloadFactory::Acquire()
-{
-    m_MemoryManager->Acquire();
-}
-
 } // namespace armnn
diff --git a/src/backends/neon/NeonWorkloadFactory.hpp b/src/backends/neon/NeonWorkloadFactory.hpp
index d5444f5..8d33063 100644
--- a/src/backends/neon/NeonWorkloadFactory.hpp
+++ b/src/backends/neon/NeonWorkloadFactory.hpp
@@ -130,10 +130,6 @@
     virtual std::unique_ptr<IWorkload> CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
                                                             const WorkloadInfo& Info) const override;
 
-    virtual void Release() override;
-
-    virtual void Acquire() override;
-
 private:
     mutable std::shared_ptr<NeonMemoryManager> m_MemoryManager;
 };
diff --git a/src/backends/neon/test/NeonCreateWorkloadTests.cpp b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
index 07953bf..61160e2 100644
--- a/src/backends/neon/test/NeonCreateWorkloadTests.cpp
+++ b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
@@ -58,7 +58,9 @@
 static void NeonCreateActivationWorkloadTest()
 {
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateActivationWorkloadTest<NeonActivationWorkload, DataType>(factory, graph);
 
     // Checks that inputs/outputs are as we expect them (see definition of CreateActivationWorkloadTest).
@@ -88,7 +90,9 @@
 static void NeonCreateArithmethicWorkloadTest()
 {
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateArithmeticWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
 
     DescriptorType queueDescriptor = workload->GetData();
@@ -157,8 +161,10 @@
 template <typename BatchNormalizationWorkloadType, typename armnn::DataType DataType>
 static void NeonCreateBatchNormalizationWorkloadTest(DataLayout dataLayout)
 {
-    Graph                graph;
-    NeonWorkloadFactory  factory = NeonWorkloadFactoryHelper::GetFactory();
+    Graph graph;
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
                     (factory, graph, dataLayout);
 
@@ -199,10 +205,11 @@
 template <typename armnn::DataType DataType>
 static void NeonCreateConvolution2dWorkloadTest(DataLayout dataLayout = DataLayout::NCHW)
 {
-    Graph                graph;
-    NeonWorkloadFactory  factory = NeonWorkloadFactoryHelper::GetFactory();
-    auto                 workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload,
-                                    DataType>(factory, graph, dataLayout);
+    Graph graph;
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
+    auto workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload, DataType>(factory, graph, dataLayout);
 
     TensorShape inputShape  = (dataLayout == DataLayout::NCHW) ? TensorShape{2, 3, 8, 16} : TensorShape{2, 8, 16, 3};
     TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{2, 2, 2, 10} : TensorShape{2, 2, 10, 2};
@@ -241,7 +248,8 @@
 static void NeonCreateDepthWiseConvolutionWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
 
     auto workload = CreateDepthwiseConvolution2dWorkloadTest<NeonDepthwiseConvolutionWorkload,
                                                              DataType>(factory, graph, dataLayout);
@@ -277,10 +285,11 @@
 template <typename FullyConnectedWorkloadType, typename armnn::DataType DataType>
 static void NeonCreateFullyConnectedWorkloadTest()
 {
-    Graph               graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
-    auto                workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType,
-                                   DataType>(factory, graph);
+    Graph graph;
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
+    auto workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateFullyConnectedWorkloadTest).
     FullyConnectedQueueDescriptor queueDescriptor = workload->GetData();
@@ -306,7 +315,9 @@
 static void NeonCreateNormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateNormalizationWorkloadTest).
@@ -347,10 +358,11 @@
 template <typename armnn::DataType DataType>
 static void NeonCreatePooling2dWorkloadTest(DataLayout dataLayout = DataLayout::NCHW)
 {
-    Graph               graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
-    auto                workload = CreatePooling2dWorkloadTest<NeonPooling2dWorkload, DataType>
-                                   (factory, graph, dataLayout);
+    Graph graph;
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
+    auto workload = CreatePooling2dWorkloadTest<NeonPooling2dWorkload, DataType>(factory, graph, dataLayout);
 
     TensorShape inputShape  = (dataLayout == DataLayout::NCHW) ? TensorShape{3, 2, 5, 5} : TensorShape{3, 5, 5, 2};
     TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{3, 2, 2, 4} : TensorShape{3, 2, 4, 2};
@@ -393,9 +405,11 @@
 template <typename armnn::DataType DataType>
 static void NeonCreateReshapeWorkloadTest()
 {
-    Graph               graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
-    auto                workload = CreateReshapeWorkloadTest<NeonReshapeWorkload, DataType>(factory, graph);
+    Graph graph;
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
+    auto workload = CreateReshapeWorkloadTest<NeonReshapeWorkload, DataType>(factory, graph);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateReshapeWorkloadTest).
     ReshapeQueueDescriptor queueDescriptor = workload->GetData();
@@ -425,8 +439,10 @@
 template <typename SoftmaxWorkloadType, typename armnn::DataType DataType>
 static void NeonCreateSoftmaxWorkloadTest()
 {
-    Graph               graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    Graph graph;
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateSoftmaxWorkloadTest).
@@ -452,7 +468,9 @@
 BOOST_AUTO_TEST_CASE(CreateSplitterWorkload)
 {
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
 
     // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
@@ -479,7 +497,8 @@
     // of the merger.
 
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
 
     auto workloads =
         CreateSplitterMergerWorkloadTest<NeonSplitterWorkload, NeonMergerWorkload,
@@ -510,7 +529,9 @@
     // We created a splitter with two outputs. That each of those outputs is used by two different activation layers
 
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     std::unique_ptr<NeonSplitterWorkload> wlSplitter;
     std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
     std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
@@ -544,7 +565,8 @@
 
 BOOST_AUTO_TEST_CASE(CreateMemCopyWorkloadsNeon)
 {
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
     CreateMemCopyWorkloads<INeonTensorHandle>(factory);
 }
 
@@ -552,7 +574,9 @@
 static void NeonCreateL2NormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     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 5695543..c6d2731 100644
--- a/src/backends/neon/test/NeonLayerSupportTests.cpp
+++ b/src/backends/neon/test/NeonLayerSupportTests.cpp
@@ -22,19 +22,22 @@
 
 BOOST_AUTO_TEST_CASE(IsLayerSupportedFloat16Neon)
 {
-    armnn::NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    armnn::NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
     IsLayerSupportedTests<armnn::NeonWorkloadFactory, armnn::DataType::Float16>(&factory);
 }
 
 BOOST_AUTO_TEST_CASE(IsLayerSupportedFloat32Neon)
 {
-    armnn::NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    armnn::NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
     IsLayerSupportedTests<armnn::NeonWorkloadFactory, armnn::DataType::Float32>(&factory);
 }
 
 BOOST_AUTO_TEST_CASE(IsLayerSupportedUint8Neon)
 {
-    armnn::NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
+    armnn::NeonWorkloadFactory factory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
     IsLayerSupportedTests<armnn::NeonWorkloadFactory, armnn::DataType::QuantisedAsymm8>(&factory);
 }
 
diff --git a/src/backends/neon/test/NeonOptimizedNetworkTests.cpp b/src/backends/neon/test/NeonOptimizedNetworkTests.cpp
index b6f4798..09e231b 100644
--- a/src/backends/neon/test/NeonOptimizedNetworkTests.cpp
+++ b/src/backends/neon/test/NeonOptimizedNetworkTests.cpp
@@ -33,7 +33,9 @@
     armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec());
     BOOST_CHECK(optNet);
     // validate workloads
-    armnn::NeonWorkloadFactory fact = NeonWorkloadFactoryHelper::GetFactory();
+    armnn::NeonWorkloadFactory fact =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
+
     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 a2bf4a9..3503c96 100644
--- a/src/backends/neon/test/NeonTimerTest.cpp
+++ b/src/backends/neon/test/NeonTimerTest.cpp
@@ -37,7 +37,8 @@
 
 BOOST_AUTO_TEST_CASE(NeonTimerMeasure)
 {
-    NeonWorkloadFactory workloadFactory = NeonWorkloadFactoryHelper::GetFactory();
+    NeonWorkloadFactory workloadFactory =
+        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
 
     unsigned int inputWidth = 4000u;
     unsigned int inputHeight = 5000u;
diff --git a/src/backends/neon/test/NeonWorkloadFactoryHelper.hpp b/src/backends/neon/test/NeonWorkloadFactoryHelper.hpp
index bcf9c57..7a6df11 100644
--- a/src/backends/neon/test/NeonWorkloadFactoryHelper.hpp
+++ b/src/backends/neon/test/NeonWorkloadFactoryHelper.hpp
@@ -9,10 +9,9 @@
 #include <backendsCommon/IMemoryManager.hpp>
 #include <backendsCommon/test/WorkloadFactoryHelper.hpp>
 
+#include <neon/NeonBackend.hpp>
 #include <neon/NeonWorkloadFactory.hpp>
 
-#include <arm_compute/runtime/Allocator.h>
-
 #include <boost/polymorphic_pointer_cast.hpp>
 
 namespace
@@ -21,12 +20,15 @@
 template<>
 struct WorkloadFactoryHelper<armnn::NeonWorkloadFactory>
 {
-    static armnn::NeonWorkloadFactory GetFactory()
+    static armnn::IBackendInternal::IMemoryManagerSharedPtr GetMemoryManager()
     {
-        armnn::IBackendInternal::IMemoryManagerSharedPtr memoryManager =
-            std::make_shared<armnn::NeonMemoryManager>(std::make_unique<arm_compute::Allocator>(),
-                                                       armnn::BaseMemoryManager::MemoryAffinity::Offset);
+        armnn::NeonBackend backend;
+        return backend.CreateMemoryManager();
+    }
 
+    static armnn::NeonWorkloadFactory GetFactory(
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    {
         return armnn::NeonWorkloadFactory(
             boost::polymorphic_pointer_downcast<armnn::NeonMemoryManager>(memoryManager));
     }
diff --git a/src/backends/reference/test/RefWorkloadFactoryHelper.hpp b/src/backends/reference/test/RefWorkloadFactoryHelper.hpp
index 5005111..b49a6dd 100644
--- a/src/backends/reference/test/RefWorkloadFactoryHelper.hpp
+++ b/src/backends/reference/test/RefWorkloadFactoryHelper.hpp
@@ -16,7 +16,14 @@
 template<>
 struct WorkloadFactoryHelper<armnn::RefWorkloadFactory>
 {
-    static armnn::RefWorkloadFactory GetFactory()
+    static armnn::IBackendInternal::IMemoryManagerSharedPtr GetMemoryManager()
+    {
+        armnn::RefBackend backend;
+        return backend.CreateMemoryManager();
+    }
+
+    static armnn::RefWorkloadFactory GetFactory(
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr)
     {
         return armnn::RefWorkloadFactory();
     }