diff --git a/Android.mk b/Android.mk
index e8bf4b6..d683c23 100644
--- a/Android.mk
+++ b/Android.mk
@@ -370,6 +370,7 @@
         src/armnn/test/optimizations/ConvertConstantsHalfToFloatTests.cpp \
         src/armnn/test/optimizations/Fp32NetworkToBf16ConverterTests.cpp \
         src/armnn/test/optimizations/Fp32NetworkToFp16ConverterTests.cpp \
+        src/armnn/test/optimizations/FuseActivationTests.cpp \
         src/armnn/test/optimizations/InsertDebugLayerTests.cpp \
         src/armnn/test/optimizations/MovePermuteUpTests.cpp \
         src/armnn/test/optimizations/OptimizeConsecutiveReshapesTests.cpp \
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 240767f..30b03dc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -647,6 +647,7 @@
         src/armnn/test/optimizations/ConvertConstantsHalfToFloatTests.cpp
         src/armnn/test/optimizations/Fp32NetworkToBf16ConverterTests.cpp
         src/armnn/test/optimizations/Fp32NetworkToFp16ConverterTests.cpp
+        src/armnn/test/optimizations/FuseActivationTests.cpp
         src/armnn/test/optimizations/FuseBatchNormTests.cpp
         src/armnn/test/optimizations/InsertDebugLayerTests.cpp
         src/armnn/test/optimizations/MovePermuteUpTests.cpp
diff --git a/include/armnn/backends/IBackendInternal.hpp b/include/armnn/backends/IBackendInternal.hpp
index 5f1b413..c7ed8ef 100644
--- a/include/armnn/backends/IBackendInternal.hpp
+++ b/include/armnn/backends/IBackendInternal.hpp
@@ -147,6 +147,9 @@
 
     virtual OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph) const;
 
+    virtual OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                   const ModelOptions& modelOptions) const;
+
     bool SupportsTensorAllocatorAPI() const;
 
     ITensorHandleFactory::FactoryId GetBackwardCompatibleFavoriteHandleFactory();
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index 5c55641..d41f2f6 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -537,6 +537,7 @@
 OptimizationResult ApplyBackendOptimizations(OptimizedNetwork* optNetObjPtr,
                                              BackendSettings& backendSettings,
                                              BackendsMap& backends,
+                                             const ModelOptions& modelOptions,
                                              Optional<std::vector<std::string>&> errMessages)
 {
     ARMNN_ASSERT(optNetObjPtr);
@@ -572,7 +573,7 @@
         for (auto& subgraph : subgraphs)
         {
             // Try to optimize the current sub-graph
-            OptimizationViews optimizationViews = backendObjPtr->OptimizeSubgraphView(*subgraph);
+            OptimizationViews optimizationViews = backendObjPtr->OptimizeSubgraphView(*subgraph, modelOptions);
             ARMNN_ASSERT(optimizationViews.Validate(*subgraph));
 
             // Optimization attempted, check the resulting optimized sub-graph
@@ -1111,6 +1112,7 @@
     OptimizationResult backendOptimizationResult = ApplyBackendOptimizations(optNetObjPtr,
                                                                              backendSettings,
                                                                              backends,
+                                                                             options.m_ModelOptions,
                                                                              messages);
     if (backendOptimizationResult.m_Error)
     {
diff --git a/src/armnn/layers/FullyConnectedLayer.cpp b/src/armnn/layers/FullyConnectedLayer.cpp
index 0dc138b..ca7a0cc 100644
--- a/src/armnn/layers/FullyConnectedLayer.cpp
+++ b/src/armnn/layers/FullyConnectedLayer.cpp
@@ -26,7 +26,6 @@
 
     FullyConnectedQueueDescriptor descriptor;
 
-    SetAdditionalInfo(descriptor);
     descriptor.m_Weight = m_Weight.get();
     if (m_Param.m_BiasEnabled)
     {
diff --git a/src/armnn/test/OptimizerTests.cpp b/src/armnn/test/OptimizerTests.cpp
index 0179589..e7eab9d 100644
--- a/src/armnn/test/OptimizerTests.cpp
+++ b/src/armnn/test/OptimizerTests.cpp
@@ -810,10 +810,10 @@
     std::vector<float> weightsVector = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
     ConstTensor        weights(TensorInfo(4, weightsDimensionSizes, DataType::Float32), weightsVector);
 
-    std::vector<float> betaVector     = {0.1f};
-    std::vector<float> gammaVector    = {0.5f};
-    std::vector<float> meanVector     = {0};
-    std::vector<float> varianceVector = {1};
+    std::vector<float> betaVector     = { 0.1f };
+    std::vector<float> gammaVector    = { 0.5f };
+    std::vector<float> meanVector     = { 0 };
+    std::vector<float> varianceVector = { 1 };
     ConstTensor        beta(TensorInfo(1, outputChannelSize, DataType::Float32), betaVector);
     ConstTensor        gamma(TensorInfo(1, outputChannelSize, DataType::Float32), gammaVector);
     ConstTensor        mean(TensorInfo(1, outputChannelSize, DataType::Float32), meanVector);
@@ -830,7 +830,7 @@
     input->GetOutputSlot().SetTensorInfo(inputInfo);
     conv->GetOutputSlot().SetTensorInfo(outputInfo);
     batchNorm->GetOutputSlot().SetTensorInfo(outputInfo);
-    conv     ->m_Weight   = std::make_unique<ScopedCpuTensorHandle>(weights);
+    conv->m_Weight        = std::make_unique<ScopedCpuTensorHandle>(weights);
     batchNorm->m_Beta     = std::make_unique<ScopedCpuTensorHandle>(beta);
     batchNorm->m_Gamma    = std::make_unique<ScopedCpuTensorHandle>(gamma);
     batchNorm->m_Mean     = std::make_unique<ScopedCpuTensorHandle>(mean);
@@ -843,9 +843,9 @@
     }
 
     // Connect layers
-    input     ->GetOutputSlot(0).Connect(conv     ->GetInputSlot(0));
-    conv      ->GetOutputSlot(0).Connect(batchNorm->GetInputSlot(0));
-    batchNorm ->GetOutputSlot(0).Connect(output   ->GetInputSlot(0));
+    input->GetOutputSlot(0).Connect(conv->GetInputSlot(0));
+    conv->GetOutputSlot(0).Connect(batchNorm->GetInputSlot(0));
+    batchNorm->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     BOOST_CHECK(4 == graph.GetNumLayers());
     BOOST_TEST(CheckSequence(graph.cbegin(),
@@ -887,10 +887,10 @@
     auto output2   = graph.AddLayer<OutputLayer>(1, "output2");
 
     // Connect layers
-    input     ->GetOutputSlot(0).Connect(conv     ->GetInputSlot(0));
-    conv      ->GetOutputSlot(0).Connect(batchNorm->GetInputSlot(0));
-    batchNorm ->GetOutputSlot(0).Connect(output   ->GetInputSlot(0));
-    conv      ->GetOutputSlot(0).Connect(output2  ->GetInputSlot(0));
+    input->GetOutputSlot(0).Connect(conv->GetInputSlot(0));
+    conv->GetOutputSlot(0).Connect(batchNorm->GetInputSlot(0));
+    batchNorm->GetOutputSlot(0).Connect(output->GetInputSlot(0));
+    conv->GetOutputSlot(0).Connect(output2->GetInputSlot(0));
 
     BOOST_CHECK(5 == graph.GetNumLayers());
     BOOST_TEST(CheckSequence(graph.cbegin(),
diff --git a/src/armnn/test/optimizations/FuseActivationTests.cpp b/src/armnn/test/optimizations/FuseActivationTests.cpp
new file mode 100644
index 0000000..0e85597
--- /dev/null
+++ b/src/armnn/test/optimizations/FuseActivationTests.cpp
@@ -0,0 +1,789 @@
+//
+// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "LayersFwd.hpp"
+
+#include <Network.hpp>
+#include <ResolveType.hpp>
+#include <armnn/INetwork.hpp>
+#include <test/TestUtils.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <QuantizeHelper.hpp>
+#include <string>
+
+using namespace armnn;
+
+BOOST_AUTO_TEST_SUITE(Optimizer)
+
+namespace
+{
+const float   g_qScale  = 1.0f;
+const int32_t g_qOffset = 0;
+
+template<typename T>
+std::vector<T> GetVector(unsigned int size, float initial, float increment)
+{
+    std::vector<float> typeVector(size, initial);
+    std::vector<T>     vector(size);
+
+    if (size > 1)
+    {
+        for (unsigned int i = 0; i < size; ++i)
+        {
+            vector[i] = T(initial + (increment * static_cast<float>(i)));
+        }
+    }
+    return vector;
+}
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct Convolution2dTest
+{
+    using LayerType = armnn::Convolution2dLayer;
+    static std::string GetReceiverLayerName() { return "Convolution2d"; };
+    static const bool isElementWise = false;
+
+    static TensorShape GetInputShape()   { return TensorShape( {1, 4, 4, 3}); }  // NHWCin
+    static TensorShape GetOutputShape()  { return TensorShape( {1, 3, 3, 4}); }  // NHWCout
+    static TensorShape GetWeightsShape() { return TensorShape( {4, 2, 2, 3}); }  // CoutHWCin
+
+    constexpr static const unsigned int inputSize  = 48; // batchIn * heightIn * widthIn * channelIn
+    constexpr static const unsigned int outputSize = 36; // batchOut * heightOut * widthOut * channelOut
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        Convolution2dDescriptor descriptor;
+        descriptor.m_BiasEnabled = false;
+        descriptor.m_DataLayout  = DataLayout::NHWC;
+        descriptor.m_StrideX     = 1;
+        descriptor.m_StrideY     = 1;
+
+        std::vector<float> weightsData   = {  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12,
+                                             11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+                                             21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+                                             31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42};
+        std::vector<T>     weightsVector = armnnUtils::QuantizedVector<T>(weightsData, g_qScale, g_qOffset);
+        TensorInfo         weightsInfo(GetWeightsShape(), ArmnnType, g_qScale, g_qOffset);
+        ConstTensor        weights(weightsInfo, weightsVector);
+        Optional<ConstTensor> optionalBias;
+
+        return network->AddConvolution2dLayer(descriptor, weights, optionalBias, name);
+    }
+};
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct DepthwiseConvolution2dTest
+{
+public:
+    using LayerType = armnn::DepthwiseConvolution2dLayer;
+    static std::string GetReceiverLayerName() { return "DepthwiseConvolution2d"; };
+    static const bool isElementWise = false;
+
+    static TensorShape GetInputShape()   { return TensorShape( {1, 4, 4, 3}); }   // NHWCin
+    static TensorShape GetOutputShape()  { return TensorShape( {1, 3, 3, 12}); }  // NHWCout
+    static TensorShape GetWeightsShape() { return TensorShape( {4, 3, 2, 2}); }   // MCinHW
+
+    constexpr static const unsigned int inputSize  = 48; //batchIn * heightIn * widthIn * channelIn;
+    constexpr static const unsigned int outputSize = 108; //batchOut * heightOut * widthOut * channelOut;
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        DepthwiseConvolution2dDescriptor descriptor;
+        descriptor.m_BiasEnabled = false;
+        descriptor.m_DataLayout  = DataLayout::NHWC;
+        descriptor.m_StrideX     = 1;
+        descriptor.m_StrideY     = 1;
+
+        std::vector<float> weightsData   = { 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12,
+                                            11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+                                            21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+                                            31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42};
+        std::vector<T>     weightsVector = armnnUtils::QuantizedVector<T>(weightsData, g_qScale, g_qOffset);
+        TensorInfo         weightsInfo(GetWeightsShape(), ArmnnType, g_qScale, g_qOffset);
+        ConstTensor        weights(weightsInfo, weightsVector);
+        Optional<ConstTensor> optionalBias;
+
+        return network->AddDepthwiseConvolution2dLayer(descriptor, weights, optionalBias, name);
+    }
+};
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct FullyConnectedTest
+{
+public:
+    using LayerType = armnn::FullyConnectedLayer;
+    static std::string GetReceiverLayerName() { return "FullyConnected"; };
+    static const bool isElementWise = false;
+
+    static TensorShape GetInputShape()   { return TensorShape( {2, 5, 1, 1}); } // NCinHW
+    static TensorShape GetOutputShape()  { return TensorShape( {2, 3}); }       // NCout
+    static TensorShape GetWeightsShape() { return TensorShape( {5, 3}); }       // CinCout
+
+    constexpr static const unsigned int inputSize  = 10; // batchIn * heightIn * widthIn * channelIn
+    constexpr static const unsigned int outputSize = 6;  // batchOut * heightOut * widthOut * channelOut
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        FullyConnectedDescriptor descriptor;
+        descriptor.m_BiasEnabled = false;
+
+        std::vector<float> weightsData   = { 1,  2,  3,  4,  5,
+                                             6,  7,  8,  9, 10,
+                                            11, 12, 13, 14, 15};
+        std::vector<T>     weightsVector = armnnUtils::QuantizedVector<T>(weightsData, g_qScale, g_qOffset);
+        TensorInfo         weightsInfo(GetWeightsShape(), ArmnnType, g_qScale, g_qOffset);
+        ConstTensor        weights(weightsInfo, weightsVector);
+        Optional<ConstTensor> optionalBias;
+
+        return network->AddFullyConnectedLayer(descriptor, weights, optionalBias, name);
+    }
+};
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct BatchNormTest
+{
+public:
+    using LayerType = armnn::BatchNormalizationLayer;
+    static std::string GetReceiverLayerName() { return "BatchNorm"; };
+    static const bool isElementWise = false;
+
+    static TensorShape GetInputShape()   { return TensorShape( {1, 4, 4, 3}); }  // NHWCin
+    static TensorShape GetOutputShape()  { return TensorShape( {1, 4, 4, 3}); }  // NHWCout
+
+    constexpr static const unsigned int inputSize  = 48; // batchIn * heightIn * widthIn * channelIn
+    constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        BatchNormalizationDescriptor descriptor;
+        descriptor.m_DataLayout = DataLayout::NHWC;
+
+        std::vector<T> betaVector     = GetVector<T>(GetOutputShape()[3], 0.0f, 0.2f);
+        std::vector<T> gammaVector    = GetVector<T>(GetOutputShape()[3], 0.5f, 0.1f);
+        std::vector<T> meanVector     = GetVector<T>(GetOutputShape()[3], 0.1f, 0.1f);
+        std::vector<T> varianceVector = GetVector<T>(GetOutputShape()[3], 1.0f, 0.1f);
+
+        const unsigned int outputChannelSize[] = { GetOutputShape()[3] };
+        ConstTensor beta(TensorInfo(1, outputChannelSize, ArmnnType), betaVector);
+        ConstTensor gamma(TensorInfo(1, outputChannelSize, ArmnnType), gammaVector);
+        ConstTensor mean(TensorInfo(1, outputChannelSize, ArmnnType), meanVector);
+        ConstTensor variance(TensorInfo(1, outputChannelSize, ArmnnType), varianceVector);
+
+        return network->AddBatchNormalizationLayer(descriptor, mean, variance, beta, gamma, name);
+    }
+};
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct MultiplicationTest
+{
+    using LayerType = armnn::MultiplicationLayer;
+    static std::string GetReceiverLayerName() { return "Multiplication"; };
+    static const bool isElementWise = true;
+
+    static TensorShape GetInputShape()   { return TensorShape( {1, 4, 4, 3}); }  // NHWCin
+    static TensorShape GetOutputShape()  { return TensorShape( {1, 4, 4, 3}); }  // NHWCout
+
+    constexpr static const unsigned int inputSize  = 48; // batchIn * heightIn * widthIn * channelIn
+    constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        return network->AddMultiplicationLayer(name);
+    }
+};
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct AdditionTest
+{
+    using LayerType = armnn::AdditionLayer;
+    static std::string GetReceiverLayerName() { return "Addition"; };
+    static const bool isElementWise = true;
+
+    static TensorShape GetInputShape()   { return TensorShape( {1, 4, 4, 3}); }  // NHWCin
+    static TensorShape GetOutputShape()  { return TensorShape( {1, 4, 4, 3}); }  // NHWCout
+
+    constexpr static const unsigned int inputSize  = 48; // batchIn * heightIn * widthIn * channelIn
+    constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        return network->AddAdditionLayer(name);
+    }
+};
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct SubtractionTest
+{
+    using LayerType = armnn::SubtractionLayer;
+    static std::string GetReceiverLayerName() { return "Subtraction"; };
+    static const bool isElementWise = true;
+
+    static TensorShape GetInputShape()   { return TensorShape( {1, 4, 4, 3}); }  // NHWCin
+    static TensorShape GetOutputShape()  { return TensorShape( {1, 4, 4, 3}); }  // NHWCout
+
+    constexpr static const unsigned int inputSize  = 48; // batchIn * heightIn * widthIn * channelIn
+    constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        return network->AddSubtractionLayer(name);
+    }
+};
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+struct DivisionTest
+{
+    using LayerType = armnn::DivisionLayer;
+    static std::string GetReceiverLayerName() { return "Division"; };
+    static const bool isElementWise = true;
+
+    static TensorShape GetInputShape()   { return TensorShape( {1, 4, 4, 3}); }  // NHWCin
+    static TensorShape GetOutputShape()  { return TensorShape( {1, 4, 4, 3}); }  // NHWCout
+
+    constexpr static const unsigned int inputSize  = 48; // batchIn * heightIn * widthIn * channelIn
+    constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut
+
+    static IConnectableLayer* AddReceiverLayer(INetwork* network,
+                                               const char* name)
+    {
+        return network->AddDivisionLayer(name);
+    }
+};
+
+} // namespace
+
+template<typename LayerTest,
+         armnn::DataType ArmnnType>
+INetworkPtr CreatNetwork(ActivationDescriptor activationDescriptor, bool preventFusing)
+{
+    // Create a network
+    INetworkPtr network = INetwork::Create();
+
+    IConnectableLayer* inputLayer = network->AddInputLayer(0);
+
+    IConnectableLayer* receiverLayer = LayerTest::AddReceiverLayer(network.get(),
+                                                                   "receiverLayer");
+
+    IConnectableLayer* activationLayer = network->AddActivationLayer(activationDescriptor,
+                                                                     "activation");
+
+    IConnectableLayer* outputLayer  = network->AddOutputLayer(0);
+    IConnectableLayer* output2Layer = preventFusing?network->AddOutputLayer(1):nullptr;
+
+    // Define layers information
+    TensorInfo inputInfo(LayerTest::GetInputShape(), ArmnnType, g_qScale, g_qOffset);
+    TensorInfo outputInfo(LayerTest::GetOutputShape(), ArmnnType, g_qScale, g_qOffset);
+
+    // Set layer information
+    inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    receiverLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+    activationLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    // Connect layers
+    inputLayer->GetOutputSlot(0).Connect(receiverLayer->GetInputSlot(0));
+    receiverLayer->GetOutputSlot(0).Connect(activationLayer->GetInputSlot(0));
+    activationLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    if (LayerTest::isElementWise)
+    {
+        inputLayer->GetOutputSlot(0).Connect(receiverLayer->GetInputSlot(1));
+    }
+    if (preventFusing)
+    {
+        receiverLayer->GetOutputSlot(0).Connect(output2Layer->GetInputSlot(0));
+    }
+
+    return network;
+}
+
+template<typename LayerTest,
+         armnn::DataType ArmnnType,
+         typename LayerType = typename LayerTest::LayerType,
+         typename T = armnn::ResolveType<ArmnnType>>
+void FuseActivationIntoPreviousLayerTest(ActivationDescriptor activationDescriptor, float tolerance, armnn::Compute
+backendId)
+{
+    // FIRST NETWORK: Fused
+    // Construct ArmNN network
+    INetworkPtr networkFused = CreatNetwork<LayerTest, ArmnnType>(activationDescriptor, false);
+
+    // Create ArmNN runtime
+    IRuntimePtr run = IRuntime::Create(IRuntime::CreationOptions()); // default options
+
+    // Optimise ArmNN network
+    IOptimizedNetworkPtr optNetFused = Optimize(*networkFused, {backendId}, run->GetDeviceSpec());
+
+    Graph graphFused = PolymorphicDowncast<OptimizedNetwork*>(optNetFused.get())->GetGraph();
+
+    auto checkFusedConv2d = [](const armnn::Layer* const layer)->bool {
+        return IsLayerOfType<LayerType>(layer) &&
+            (layer->GetNameStr() == "fused-activation-into-receiverLayer");
+    };
+
+    BOOST_CHECK_MESSAGE(3 == graphFused.GetNumLayers(), LayerTest::GetReceiverLayerName());
+    BOOST_TEST(CheckSequence(graphFused.cbegin(),
+                             graphFused.cend(),
+                             &IsLayerOfType<InputLayer>,
+                             checkFusedConv2d,
+                             &IsLayerOfType<OutputLayer>));
+
+    // Load network into runtime
+    NetworkId networkIdentifier;
+    BOOST_TEST(run->LoadNetwork(networkIdentifier, std::move(optNetFused)) == Status::Success);
+
+    //Creates structures for inputs and outputs.
+    std::vector<float> data = GetVector<float>(LayerTest::inputSize, 1.0f, 0.1f);
+    std::vector<T> inputDataFused = armnnUtils::QuantizedVector<T>(data, g_qScale, g_qOffset);
+    std::vector<T> outputDataFused(LayerTest::outputSize);
+
+    InputTensors  inputTensorsFused{
+        {0, ConstTensor(run->GetInputTensorInfo(networkIdentifier, 0), inputDataFused.data())}};
+    OutputTensors outputTensorsFused{
+        {0, Tensor(run->GetOutputTensorInfo(networkIdentifier, 0), outputDataFused.data())}};
+
+    // Execute network
+    run->EnqueueWorkload(networkIdentifier, inputTensorsFused, outputTensorsFused);
+
+    // SECOND NETWORK: NotFused
+    // Construct ArmNN network
+    INetworkPtr networkNotFused = CreatNetwork<LayerTest, ArmnnType>(activationDescriptor, true);
+
+    // Create ArmNN runtime
+    IRuntimePtr runNotFused = IRuntime::Create(IRuntime::CreationOptions()); // default options
+
+    // Optimise ArmNN network
+    IOptimizedNetworkPtr optNetNotFused = Optimize(*networkNotFused, {backendId}, runNotFused->GetDeviceSpec());
+
+    Graph graphNotFused = PolymorphicDowncast<OptimizedNetwork*>(optNetNotFused.get())->GetGraph();
+
+    BOOST_CHECK(5 == graphNotFused.GetNumLayers());
+    BOOST_TEST(CheckSequence(graphNotFused.cbegin(),
+                             graphNotFused.cend(),
+                             &IsLayerOfType<armnn::InputLayer>,
+                             &IsLayerOfType<LayerType>,
+                             &IsLayerOfType<armnn::ActivationLayer>,
+                             &IsLayerOfType<armnn::OutputLayer>,
+                             &IsLayerOfType<armnn::OutputLayer>));
+
+    // Load network into runtime
+    NetworkId networkIdentifierNotFused;
+    BOOST_TEST(runNotFused->LoadNetwork(networkIdentifierNotFused, std::move(optNetNotFused)) == Status::Success);
+
+    //Creates structures for inputs and outputs.
+    std::vector<T> inputDataNotFused = armnnUtils::QuantizedVector<T>(data, g_qScale, g_qOffset);
+    std::vector<T> outputDataNotFused(LayerTest::outputSize);
+    std::vector<T> outputData2NotFused(LayerTest::outputSize);
+
+    InputTensors  inputTensorsNotFused{
+        {0, ConstTensor(runNotFused->GetInputTensorInfo(networkIdentifierNotFused, 0), inputDataNotFused.data())}};
+    OutputTensors outputTensorsNotFused{
+        {0, Tensor(runNotFused->GetOutputTensorInfo(networkIdentifierNotFused, 0), outputDataNotFused.data())},
+        {1, Tensor(runNotFused->GetOutputTensorInfo(networkIdentifierNotFused, 1), outputData2NotFused.data())}};
+
+    // Execute network
+    runNotFused->EnqueueWorkload(networkIdentifierNotFused, inputTensorsNotFused, outputTensorsNotFused);
+
+    // Check the output of the fused-activation matches with the output of the activation in the "NotFused" network
+    for (unsigned int n = 0; n < outputDataFused.size(); ++n)
+    {
+        BOOST_CHECK_CLOSE(static_cast<float>(outputDataFused[n]), static_cast<float>(outputDataNotFused[n]),
+                          T(tolerance));
+    }
+}
+
+#if defined(ARMCOMPUTENEON_ENABLED)
+// ReLu fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseReLUIntoConvFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoDWConvFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<DepthwiseConvolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<FullyConnectedTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoBatchNormFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<BatchNormTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+
+// BoundedReLu fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoConvFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDWConvFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest < DepthwiseConvolution2dTest < DataType::Float32 > , DataType::Float32 >
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoFullyConnectedFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<FullyConnectedTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoBatchNormFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<BatchNormTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+
+// ReLU fused into Receiver Layers QAsymmU8
+BOOST_AUTO_TEST_CASE(FuseReLUIntoConvQAsymmU8CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::QAsymmU8>, DataType::QAsymmU8>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoDWConvQAsymmU8CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<DepthwiseConvolution2dTest<DataType::QAsymmU8>, DataType::QAsymmU8>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedQAsymmU8CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<FullyConnectedTest<DataType::QAsymmU8>, DataType::QAsymmU8>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+
+// HardSwish fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseHardSwishIntoConvFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::HardSwish;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+
+// TanH fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseTanHIntoConvFloat32CpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::TanH;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc);
+}
+#endif
+
+#if defined(ARMCOMPUTECL_ENABLED)
+// ReLu fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseReLUIntoConvFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoDWConvFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<DepthwiseConvolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<FullyConnectedTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoBatchNormFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<BatchNormTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoMulFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<MultiplicationTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoAddFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<AdditionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoSubFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<SubtractionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUIntoDivFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<DivisionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+
+// BoundedReLu fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoConvFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDWConvFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<DepthwiseConvolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoFullyConnectedFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<FullyConnectedTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoBatchNormFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<BatchNormTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoMulFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<MultiplicationTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoAddFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<AdditionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoSubFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<SubtractionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDivFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
+    activationDescriptor.m_A = 1.0f;
+    activationDescriptor.m_B = -1.0f;
+
+    FuseActivationIntoPreviousLayerTest<DivisionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+
+// ReLU fused into Receiver Layers QAsymmU8
+BOOST_AUTO_TEST_CASE(FuseReLUQIntoConvAsymmU8GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::QAsymmU8>, DataType::QAsymmU8>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUQIntoDWConvAsymmU8GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<DepthwiseConvolution2dTest<DataType::QAsymmU8>, DataType::QAsymmU8>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseReLUQIntoFullyConnectedAsymmU8GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::ReLu;
+
+    FuseActivationIntoPreviousLayerTest<FullyConnectedTest<DataType::QAsymmU8>, DataType::QAsymmU8>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+
+// HardSwish fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseHardSwishIntoConvFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::HardSwish;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseHardSwishIntoMulFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::HardSwish;
+
+    FuseActivationIntoPreviousLayerTest<MultiplicationTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseHardSwishIntoAddFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::HardSwish;
+
+    FuseActivationIntoPreviousLayerTest<AdditionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseHardSwishIntoSubFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::HardSwish;
+
+    FuseActivationIntoPreviousLayerTest<SubtractionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseHardSwishIntoDivFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::HardSwish;
+
+    FuseActivationIntoPreviousLayerTest<DivisionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+
+// TanH fused into Receiver Layers Float32
+BOOST_AUTO_TEST_CASE(FuseTanHIntoConvFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::TanH;
+
+    FuseActivationIntoPreviousLayerTest<Convolution2dTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseTanHIntoMulFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::TanH;
+
+    FuseActivationIntoPreviousLayerTest<MultiplicationTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseTanHIntoAddFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::TanH;
+
+    FuseActivationIntoPreviousLayerTest<AdditionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseTanHIntoSubFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::TanH;
+
+    FuseActivationIntoPreviousLayerTest<SubtractionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+BOOST_AUTO_TEST_CASE(FuseTanHIntoDivFloat32GpuAccTest)
+{
+    ActivationDescriptor activationDescriptor;
+    activationDescriptor.m_Function = ActivationFunction::TanH;
+
+    FuseActivationIntoPreviousLayerTest<DivisionTest<DataType::Float32>, DataType::Float32>
+        (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc);
+}
+#endif
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/src/backends/aclCommon/ArmComputeSubgraphUtils.hpp b/src/backends/aclCommon/ArmComputeSubgraphUtils.hpp
new file mode 100644
index 0000000..79744ec
--- /dev/null
+++ b/src/backends/aclCommon/ArmComputeSubgraphUtils.hpp
@@ -0,0 +1,145 @@
+//
+// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/backends/OptimizationViews.hpp>
+
+namespace armnn
+{
+
+namespace
+{
+
+//
+// this helper only works if all layers where the inputs connect to are not selected
+//
+SubgraphView::InputSlots CreateInputsFrom(const std::vector<Layer*>& layers)
+{
+    SubgraphView::InputSlots result;
+    for (auto&& layer : layers)
+    {
+        for (auto&& it = layer->BeginInputSlots(); it != layer->EndInputSlots(); ++it)
+        {
+            result.push_back(&(*it));
+        }
+    }
+    return result;
+}
+
+//
+// this helper only works if all layers where the outputs connect to are not selected
+//
+SubgraphView::OutputSlots CreateOutputsFrom(const std::vector<Layer*>& layers)
+{
+    SubgraphView::OutputSlots result;
+    for (auto&& layer : layers)
+    {
+        for (auto&& it = layer->BeginOutputSlots(); it != layer->EndOutputSlots(); ++it)
+        {
+            result.push_back(&(*it));
+        }
+    }
+    return result;
+}
+
+} // namespace
+
+inline const TensorInfo GetOverriddenDataType(const TensorInfo& info, Optional<DataType> type)
+{
+    if (!type)
+    {
+        return info;
+    }
+
+    return TensorInfo(info.GetShape(), type.value(), info.GetQuantizationScale(), info.GetQuantizationOffset());
+}
+
+inline armnn::Optional<armnn::DataType> GetOptionalBiasTypeFromWeightsType(armnn::Optional<armnn::DataType> weightsType)
+{
+    if (!weightsType)
+    {
+        return weightsType;
+    }
+
+    switch(weightsType.value())
+    {
+        case armnn::DataType::BFloat16:
+        case armnn::DataType::Float16:
+        case armnn::DataType::Float32:
+            return weightsType;
+        case armnn::DataType::QAsymmS8:
+            return armnn::DataType::Signed32;
+        case armnn::DataType::QAsymmU8:
+            return armnn::DataType::Signed32;
+        case armnn::DataType::QSymmS16:
+            return armnn::DataType::Signed32;
+        default:
+            ARMNN_ASSERT_MSG(false, "GetBiasTypeFromWeightsType(): Unsupported data type.");
+    }
+    return armnn::EmptyOptional();
+}
+
+template<typename LayerType>
+LayerType* FuseLayerWithoutParameters(OptimizationViews& optimizationViews,
+                                      LayerType* baseLayer,
+                                      ActivationLayer* activationLayer,
+                                      ActivationDescriptor& activationDesc,
+                                      std::string name)
+{
+    LayerType* replacementLayer = optimizationViews.GetGraph().AddLayer<LayerType>(name.c_str());
+
+    replacementLayer->SetAdditionalInfoForObject(std::make_shared<ActivationDescriptor>(activationDesc));
+
+    SubgraphView substitutionSubgraph(CreateInputsFrom({baseLayer}),
+                                      CreateOutputsFrom({activationLayer}),
+                                      {baseLayer, activationLayer});
+    SubgraphView replacementSubgraph(replacementLayer);
+
+    optimizationViews.AddSubstitution({substitutionSubgraph, replacementSubgraph});
+    return replacementLayer;
+}
+
+template<typename LayerType>
+LayerType* FuseLayerWithParameters(OptimizationViews& optimizationViews,
+                                   LayerType* baseLayer,
+                                   ActivationLayer* activationLayer,
+                                   ActivationDescriptor& activationDesc,
+                                   std::string name)
+{
+    LayerType* replacementLayer = optimizationViews.GetGraph().AddLayer<LayerType>(baseLayer->GetParameters(),
+                                                                                   name.c_str());
+
+    replacementLayer->SetAdditionalInfoForObject(std::make_shared<ActivationDescriptor>(activationDesc));
+
+    SubgraphView substitutionSubgraph(CreateInputsFrom({baseLayer}),
+                                      CreateOutputsFrom({activationLayer}),
+                                      {baseLayer, activationLayer});
+    SubgraphView replacementSubgraph(replacementLayer);
+
+    optimizationViews.AddSubstitution({substitutionSubgraph, replacementSubgraph});
+    return replacementLayer;
+}
+
+template<typename LayerType>
+LayerType* FuseLayerWithWeightsAndBiases(OptimizationViews& optimizationViews,
+                                         LayerType* baseLayer,
+                                         ActivationLayer* activationLayer,
+                                         ActivationDescriptor& activationDesc,
+                                         std::string name)
+{
+    LayerType* replacementLayer = FuseLayerWithParameters(optimizationViews,
+                                                          baseLayer,
+                                                          activationLayer,
+                                                          activationDesc,
+                                                          name);
+
+    replacementLayer->m_Weight = std::move(baseLayer->m_Weight);
+    replacementLayer->m_Bias   = std::move(baseLayer->m_Bias);
+
+    return replacementLayer;
+}
+
+} // namespace armnn
diff --git a/src/backends/aclCommon/ArmComputeUtils.hpp b/src/backends/aclCommon/ArmComputeUtils.hpp
index 6b1f975..adcf828 100644
--- a/src/backends/aclCommon/ArmComputeUtils.hpp
+++ b/src/backends/aclCommon/ArmComputeUtils.hpp
@@ -9,6 +9,8 @@
 #include <armnn/utility/Assert.hpp>
 
 #include <arm_compute/core/Types.h>
+#include "../../../../clframework/arm_compute/core/Types.h"
+#include "../backendsCommon/WorkloadData.hpp"
 
 namespace armnn
 {
@@ -77,6 +79,30 @@
         actDesc.m_A, actDesc.m_B);
 }
 
+inline arm_compute::ActivationLayerInfo
+ConvertActivationDescriptorToAclActivationLayerInfo(const ActivationDescriptor* activationDescPtr)
+{
+    if (activationDescPtr != nullptr)
+    {
+        return ConvertActivationDescriptorToAclActivationLayerInfo(static_cast<ActivationDescriptor>(
+                                                                           *activationDescPtr));
+    }
+    return arm_compute::ActivationLayerInfo();
+}
+
+inline arm_compute::ActivationLayerInfo
+ConvertAdditionalInfoToAclActivationLayerInfo(const QueueDescriptor& queueDescriptor)
+{
+    const ActivationDescriptor* activationDescPtr = queueDescriptor.GetAdditionalInformation<ActivationDescriptor>();
+
+    if (activationDescPtr != nullptr)
+    {
+        return ConvertActivationDescriptorToAclActivationLayerInfo(static_cast<ActivationDescriptor>(
+                *activationDescPtr));
+    }
+    return arm_compute::ActivationLayerInfo();
+}
+
 inline arm_compute::ComparisonOperation ConvertComparisonOperationToAcl(const ComparisonDescriptor& descriptor)
 {
     switch (descriptor.m_Operation)
@@ -130,10 +156,22 @@
 }
 
 inline arm_compute::FullyConnectedLayerInfo
-ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(const FullyConnectedDescriptor& fullyConnectedDesc)
+ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(const FullyConnectedDescriptor& fullyConnectedDesc,
+                                                            const ActivationDescriptor* activationDesc)
 {
     arm_compute::FullyConnectedLayerInfo fc_info;
     fc_info.transpose_weights = fullyConnectedDesc.m_TransposeWeightMatrix;
+    fc_info.activation_info = ConvertActivationDescriptorToAclActivationLayerInfo(activationDesc);
+    return fc_info;
+}
+
+inline arm_compute::FullyConnectedLayerInfo
+ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(const FullyConnectedDescriptor& fullyConnectedDesc,
+        arm_compute::ActivationLayerInfo activationLayerInfo)
+{
+    arm_compute::FullyConnectedLayerInfo fc_info;
+    fc_info.transpose_weights = fullyConnectedDesc.m_TransposeWeightMatrix;
+    fc_info.activation_info = activationLayerInfo;
     return fc_info;
 }
 
diff --git a/src/backends/aclCommon/CMakeLists.txt b/src/backends/aclCommon/CMakeLists.txt
index fa80437..dac663b 100644
--- a/src/backends/aclCommon/CMakeLists.txt
+++ b/src/backends/aclCommon/CMakeLists.txt
@@ -7,6 +7,7 @@
     ArmComputeTensorHandle.hpp
     ArmComputeTensorUtils.hpp
     ArmComputeTensorUtils.cpp
+    ArmComputeSubgraphUtils.hpp
     ArmComputeUtils.hpp
     BaseMemoryManager.cpp
     BaseMemoryManager.hpp
diff --git a/src/backends/backendsCommon/IBackendInternal.cpp b/src/backends/backendsCommon/IBackendInternal.cpp
index 81fc515..b08dff8 100644
--- a/src/backends/backendsCommon/IBackendInternal.cpp
+++ b/src/backends/backendsCommon/IBackendInternal.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include <armnn/BackendOptions.hpp>
 #include <armnn/backends/IBackendInternal.hpp>
 
 namespace armnn
@@ -135,6 +136,12 @@
     return result;
 }
 
+OptimizationViews IBackendInternal::OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                         const ModelOptions& /*modelOptions*/) const
+{
+    return OptimizeSubgraphView(subgraph);
+}
+
 bool IBackendInternal::SupportsTensorAllocatorAPI() const
 {
     return !GetHandleFactoryPreferences().empty();
diff --git a/src/backends/backendsCommon/WorkloadData.hpp b/src/backends/backendsCommon/WorkloadData.hpp
index dd39d31..0a232dc 100644
--- a/src/backends/backendsCommon/WorkloadData.hpp
+++ b/src/backends/backendsCommon/WorkloadData.hpp
@@ -36,7 +36,7 @@
                                unsigned int numExpectedOut) const;
 
     template<typename T>
-    const T* GetAdditionalInformation()
+    const T* GetAdditionalInformation() const
     {
         return static_cast<T*>(m_AdditionalInfoObject);
     }
diff --git a/src/backends/cl/ClBackend.cpp b/src/backends/cl/ClBackend.cpp
index 6254b0a..57a5851 100644
--- a/src/backends/cl/ClBackend.cpp
+++ b/src/backends/cl/ClBackend.cpp
@@ -12,16 +12,28 @@
 #include "ClTensorHandleFactory.hpp"
 
 #include <armnn/BackendRegistry.hpp>
+#include <armnn/Descriptors.hpp>
 
+#include <aclCommon/ArmComputeSubgraphUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
 #include <aclCommon/BaseMemoryManager.hpp>
 
 #include <armnn/backends/IBackendContext.hpp>
 #include <armnn/backends/IMemoryManager.hpp>
-
 #include <armnn/utility/PolymorphicDowncast.hpp>
 
+#include "workloads/ClAdditionWorkload.hpp"
+#include "workloads/ClBatchNormalizationFloatWorkload.hpp"
+#include "workloads/ClConvolution2dWorkload.hpp"
+#include "workloads/ClDepthwiseConvolutionWorkload.hpp"
+#include "workloads/ClDivisionFloatWorkload.hpp"
+#include "workloads/ClFullyConnectedWorkload.hpp"
+#include "workloads/ClMultiplicationWorkload.hpp"
+#include "workloads/ClSubtractionWorkload.hpp"
+
 #include <Optimizer.hpp>
 
+#include <arm_compute/core/Types.h>
 #include <arm_compute/runtime/CL/CLBufferAllocator.h>
 
 namespace armnn
@@ -129,11 +141,256 @@
     return layerSupport;
 }
 
-OptimizationViews ClBackend::OptimizeSubgraphView(const SubgraphView& subgraph) const
+OptimizationViews ClBackend::OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                  const ModelOptions& modelOptions) const
 {
     OptimizationViews optimizationViews;
 
-    optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
+    auto it = subgraph.end();
+    bool isFastMathEnabled = false;
+
+#if defined(ARMCOMPUTECL_ENABLED)
+    IBackendInternal::IBackendSpecificModelContextPtr modelContextPtr = CreateBackendSpecificModelContext(modelOptions);
+
+    if (modelContextPtr)
+    {
+        auto clModelOptions = dynamic_cast<ClBackendModelContext*>(modelContextPtr.get());
+        if (clModelOptions)
+        {
+            isFastMathEnabled = clModelOptions->IsFastMathEnabled();
+        }
+    }
+#endif
+
+    while (it != subgraph.begin())
+    {
+        --it;
+        Layer& base = **it;
+
+        if ((base.GetType() == LayerType::DepthwiseConvolution2d || base.GetType() == LayerType::Convolution2d
+            || base.GetType() == LayerType::BatchNormalization || base.GetType() == LayerType::FullyConnected
+            || base.GetType() == LayerType::Addition || base.GetType() == LayerType::Multiplication
+            || base.GetType() == LayerType::Subtraction || base.GetType() == LayerType::Division)
+            && (base.GetAdditionalInformation<ActivationDescriptor>() == nullptr))
+        {
+            for (auto output = base.BeginOutputSlots(); output != base.EndOutputSlots(); ++output)
+            {
+                if (output->GetNumConnections() == 1)
+                {
+                    for (auto&& childInput : output->GetConnections())
+                    {
+                        if (childInput->GetOwningLayer().GetType() == LayerType::Activation)
+                        {
+                            Layer& child = childInput->GetOwningLayer();
+
+                            auto* activationLayer = PolymorphicDowncast<ActivationLayer*>(&child);
+
+                            const std::string name = std::string("fused-") + child.GetName() + std::string("-into-") +
+                                                     base.GetName();
+
+                            // Get params from activation layer
+                            ActivationDescriptor activationDesc = activationLayer->GetParameters();
+
+                            if (base.GetType() == LayerType::Convolution2d)
+                            {
+                                Convolution2dLayer* baseLayer = PolymorphicDowncast<Convolution2dLayer*>(&base);
+
+                                Optional<TensorInfo> biases;
+
+                                if (baseLayer->GetParameters().m_BiasEnabled)
+                                {
+                                    biases = GetOverriddenDataType(baseLayer->m_Bias->GetTensorInfo(),
+                                            GetOptionalBiasTypeFromWeightsType(
+                                                    baseLayer->m_Weight->GetTensorInfo().GetDataType()));
+                                }
+
+                                arm_compute::Status status = ClConvolution2dWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        baseLayer->m_Weight->GetTensorInfo(),
+                                        biases,
+                                        isFastMathEnabled,
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithWeightsAndBiases<Convolution2dLayer>(optimizationViews,
+                                                                                      baseLayer,
+                                                                                      activationLayer,
+                                                                                      activationDesc,
+                                                                                      name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::DepthwiseConvolution2d)
+                            {
+                                DepthwiseConvolution2dLayer* baseLayer =
+                                        PolymorphicDowncast<DepthwiseConvolution2dLayer*>(&base);
+
+                                Optional<TensorInfo> biases;
+
+                                if (baseLayer->GetParameters().m_BiasEnabled)
+                                {
+                                    biases = GetOverriddenDataType(baseLayer->m_Bias->GetTensorInfo(),
+                                            GetOptionalBiasTypeFromWeightsType(
+                                                    baseLayer->m_Weight->GetTensorInfo().GetDataType()));
+                                }
+
+                                arm_compute::Status status = ClDepthwiseConvolutionWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        baseLayer->m_Weight->GetTensorInfo(),
+                                        biases,
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithWeightsAndBiases<DepthwiseConvolution2dLayer>(optimizationViews,
+                                                                                               baseLayer,
+                                                                                               activationLayer,
+                                                                                               activationDesc,
+                                                                                               name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::FullyConnected)
+                            {
+                                FullyConnectedLayer* baseLayer = PolymorphicDowncast<FullyConnectedLayer*>(&base);
+
+                                arm_compute::Status status = ClFullyConnectedWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->m_Weight->GetTensorInfo(),
+                                        baseLayer->m_Bias->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithWeightsAndBiases<FullyConnectedLayer>(optimizationViews,
+                                                                                       baseLayer,
+                                                                                       activationLayer,
+                                                                                       activationDesc,
+                                                                                       name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::BatchNormalization)
+                            {
+                                BatchNormalizationLayer* baseLayer =
+                                        PolymorphicDowncast<BatchNormalizationLayer*>(&base);
+
+                                arm_compute::Status status = ClBatchNormalizationValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->m_Mean->GetTensorInfo(),
+                                        baseLayer->m_Variance->GetTensorInfo(),
+                                        baseLayer->m_Beta->GetTensorInfo(),
+                                        baseLayer->m_Gamma->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    BatchNormalizationLayer* replacementLayer =
+                                            FuseLayerWithParameters<BatchNormalizationLayer>(optimizationViews,
+                                                                                             baseLayer,
+                                                                                             activationLayer,
+                                                                                             activationDesc,
+                                                                                             name);
+
+                                    replacementLayer->m_Beta     = std::move(baseLayer->m_Beta);
+                                    replacementLayer->m_Gamma    = std::move(baseLayer->m_Gamma);
+                                    replacementLayer->m_Mean     = std::move(baseLayer->m_Mean);
+                                    replacementLayer->m_Variance = std::move(baseLayer->m_Variance);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Addition)
+                            {
+                                AdditionLayer* baseLayer = PolymorphicDowncast<AdditionLayer*>(&base);
+
+                                arm_compute::Status status = ClAdditionValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<AdditionLayer>(optimizationViews,
+                                                                              baseLayer,
+                                                                              activationLayer,
+                                                                              activationDesc,
+                                                                              name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Division)
+                            {
+                                DivisionLayer* baseLayer = PolymorphicDowncast<DivisionLayer*>(&base);
+
+                                arm_compute::Status status = ClDivisionWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<DivisionLayer>(optimizationViews,
+                                                                              baseLayer,
+                                                                              activationLayer,
+                                                                              activationDesc,
+                                                                              name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Multiplication)
+                            {
+                                MultiplicationLayer* baseLayer = PolymorphicDowncast<MultiplicationLayer*>(&base);
+
+                                arm_compute::Status status = ClMultiplicationWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<MultiplicationLayer>(optimizationViews,
+                                                                                    baseLayer,
+                                                                                    activationLayer,
+                                                                                    activationDesc,
+                                                                                    name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Subtraction)
+                            {
+                                SubtractionLayer* baseLayer = PolymorphicDowncast<SubtractionLayer*>(&base);
+
+                                arm_compute::Status status = ClSubtractionValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<SubtractionLayer>(optimizationViews,
+                                                                                 baseLayer,
+                                                                                 activationLayer,
+                                                                                 activationDesc,
+                                                                                 name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // end each optimization
+    if (optimizationViews.GetSubstitutions().empty())
+    {
+        optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
+    }
 
     return optimizationViews;
 }
diff --git a/src/backends/cl/ClBackend.hpp b/src/backends/cl/ClBackend.hpp
index af5534e..2b19fc5 100644
--- a/src/backends/cl/ClBackend.hpp
+++ b/src/backends/cl/ClBackend.hpp
@@ -44,7 +44,8 @@
     IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override;
     IBackendInternal::ILayerSupportSharedPtr GetLayerSupport(const ModelOptions& modelOptions) const override;
 
-    OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph) const override;
+    OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph,
+                                           const ModelOptions& modelOptions) const override;
 
     IBackendInternal::IBackendSpecificModelContextPtr CreateBackendSpecificModelContext(
         const ModelOptions& modelOptions) const override;
diff --git a/src/backends/cl/ClLayerSupport.cpp b/src/backends/cl/ClLayerSupport.cpp
index 7c1466e..cce5c9b 100644
--- a/src/backends/cl/ClLayerSupport.cpp
+++ b/src/backends/cl/ClLayerSupport.cpp
@@ -197,7 +197,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsArgMinMaxSupported(const TensorInfo& input,
@@ -230,7 +231,8 @@
                                    var,
                                    beta,
                                    gamma,
-                                   descriptor);
+                                   descriptor,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
@@ -357,7 +359,8 @@
                                    descriptor,
                                    weights,
                                    biases,
-                                   isFastMathEnabled);
+                                   isFastMathEnabled,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsDequantizeSupported(const TensorInfo& input,
@@ -395,7 +398,8 @@
                                    output,
                                    descriptor,
                                    weights,
-                                   biases);
+                                   biases,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
@@ -411,7 +415,8 @@
                                    output,
                                    descriptor,
                                    weights,
-                                   biases);
+                                   biases,
+                                   nullptr);
 }
 
 
@@ -424,7 +429,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
@@ -494,7 +500,8 @@
                                    output,
                                    weights,
                                    biases,
-                                   descriptor);
+                                   descriptor,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsGatherSupported(const TensorInfo& input0,
@@ -639,7 +646,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsNormalizationSupported(const TensorInfo& input,
@@ -911,7 +919,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool ClLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input,
diff --git a/src/backends/cl/workloads/ClAdditionWorkload.cpp b/src/backends/cl/workloads/ClAdditionWorkload.cpp
index 18e2400..7e75a04 100644
--- a/src/backends/cl/workloads/ClAdditionWorkload.cpp
+++ b/src/backends/cl/workloads/ClAdditionWorkload.cpp
@@ -8,6 +8,7 @@
 #include <cl/ClTensorHandle.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
 #include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
 
 #include "ClWorkloadUtils.hpp"
 
@@ -26,7 +27,10 @@
     arm_compute::ICLTensor& input0 = static_cast<IClTensorHandle*>(this->m_Data.m_Inputs[0])->GetTensor();
     arm_compute::ICLTensor& input1 = static_cast<IClTensorHandle*>(this->m_Data.m_Inputs[1])->GetTensor();
     arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(this->m_Data.m_Outputs[0])->GetTensor();
-    m_Layer.configure(&input0, &input1, &output, g_AclConvertPolicy);
+
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
+    m_Layer.configure(&input0, &input1, &output, g_AclConvertPolicy, activationInfo);
 }
 
 void ClAdditionWorkload::Execute() const
@@ -37,16 +41,21 @@
 
 arm_compute::Status ClAdditionValidate(const TensorInfo& input0,
                                        const TensorInfo& input1,
-                                       const TensorInfo& output)
+                                       const TensorInfo& output,
+                                       const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput0Info = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1Info = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     const arm_compute::Status aclStatus = arm_compute::CLArithmeticAddition::validate(&aclInput0Info,
                                                                                       &aclInput1Info,
                                                                                       &aclOutputInfo,
-                                                                                      g_AclConvertPolicy);
+                                                                                      g_AclConvertPolicy,
+                                                                                      activationInfo);
 
     return aclStatus;
 }
diff --git a/src/backends/cl/workloads/ClAdditionWorkload.hpp b/src/backends/cl/workloads/ClAdditionWorkload.hpp
index 62bd0ae..372c4bc 100644
--- a/src/backends/cl/workloads/ClAdditionWorkload.hpp
+++ b/src/backends/cl/workloads/ClAdditionWorkload.hpp
@@ -25,5 +25,6 @@
 
 arm_compute::Status ClAdditionValidate(const TensorInfo& input0,
                                        const TensorInfo& input1,
-                                       const TensorInfo& output);
+                                       const TensorInfo& output,
+                                       const ActivationDescriptor* activationDescriptor = nullptr);
 } //namespace armnn
diff --git a/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp b/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp
index fa0be85..68942e2 100644
--- a/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp
+++ b/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp
@@ -4,13 +4,17 @@
 //
 
 #include "ClBatchNormalizationFloatWorkload.hpp"
-#include <cl/ClTensorHandle.hpp>
-#include <backendsCommon/CpuTensorHandle.hpp>
-#include <aclCommon/ArmComputeTensorUtils.hpp>
-#include <cl/ClLayerSupport.hpp>
-
 #include "ClWorkloadUtils.hpp"
 
+#include <cl/ClTensorHandle.hpp>
+
+#include <backendsCommon/CpuTensorHandle.hpp>
+
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+
+#include <cl/ClLayerSupport.hpp>
+
 namespace armnn
 {
 using namespace armcomputetensorutils;
@@ -21,7 +25,8 @@
                                                  const TensorInfo& var,
                                                  const TensorInfo& beta,
                                                  const TensorInfo& gamma,
-                                                 const BatchNormalizationDescriptor &desc)
+                                                 const BatchNormalizationDescriptor& desc,
+                                                 const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInputInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(input, desc.m_DataLayout);
@@ -36,13 +41,17 @@
     const arm_compute::TensorInfo aclGammaInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(gamma, desc.m_DataLayout);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::CLBatchNormalizationLayer::validate(&aclInputInfo,
                                                             &aclOutputInfo,
                                                             &aclMeanInfo,
                                                             &aclVarInfo,
                                                             &aclBetaInfo,
                                                             &aclGammaInfo,
-                                                            desc.m_Eps);
+                                                            desc.m_Eps,
+                                                            activationInfo);
 }
 
 ClBatchNormalizationFloatWorkload::ClBatchNormalizationFloatWorkload(
@@ -70,13 +79,16 @@
     input.info()->set_data_layout(aclDataLayout);
     output.info()->set_data_layout(aclDataLayout);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     m_Layer.configure(&input,
                       &output,
                       m_Mean.get(),
                       m_Variance.get(),
                       m_Beta.get(),
                       m_Gamma.get(),
-                      m_Data.m_Parameters.m_Eps);
+                      m_Data.m_Parameters.m_Eps,
+                      activationInfo);
 
     InitializeArmComputeClTensorData(*m_Mean, m_Data.m_Mean);
     InitializeArmComputeClTensorData(*m_Variance, m_Data.m_Variance);
diff --git a/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.hpp b/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.hpp
index e94bef2..ef57783 100644
--- a/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.hpp
+++ b/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.hpp
@@ -19,7 +19,8 @@
                                                  const TensorInfo& var,
                                                  const TensorInfo& beta,
                                                  const TensorInfo& gamma,
-                                                 const BatchNormalizationDescriptor& desc);
+                                                 const BatchNormalizationDescriptor& desc,
+                                                 const ActivationDescriptor* activationDescriptor = nullptr);
 
 class ClBatchNormalizationFloatWorkload : public FloatWorkload<BatchNormalizationQueueDescriptor>
 {
diff --git a/src/backends/cl/workloads/ClConvolution2dWorkload.cpp b/src/backends/cl/workloads/ClConvolution2dWorkload.cpp
index 7b52f27..50cb9de 100644
--- a/src/backends/cl/workloads/ClConvolution2dWorkload.cpp
+++ b/src/backends/cl/workloads/ClConvolution2dWorkload.cpp
@@ -25,7 +25,8 @@
                                                     const Convolution2dDescriptor& descriptor,
                                                     const TensorInfo& weights,
                                                     const Optional<TensorInfo>& biases,
-                                                    bool isFastMathEnabled)
+                                                    bool isFastMathEnabled,
+                                                    const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
@@ -47,6 +48,9 @@
 
     arm_compute::PadStrideInfo layerInfo = BuildArmComputePadStrideInfo(descriptor);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::CLConvolutionLayer::validate(&aclInputInfo,
                                                      &aclWeightsInfo,
                                                      optionalAclBiasesInfo,
@@ -54,7 +58,7 @@
                                                      layerInfo,
                                                      arm_compute::WeightsInfo(),
                                                      aclDilationInfo,
-                                                     arm_compute::ActivationLayerInfo(),
+                                                     activationInfo,
                                                      isFastMathEnabled);
 }
 
@@ -91,6 +95,8 @@
 
     arm_compute::PadStrideInfo padStrideInfo = BuildArmComputePadStrideInfo(m_Data.m_Parameters);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     m_ConvolutionLayer.configure(&input,
                                  m_KernelTensor.get(),
                                  m_BiasTensor.get(),
@@ -98,7 +104,7 @@
                                  padStrideInfo,
                                  arm_compute::WeightsInfo(),
                                  aclDilationInfo,
-                                 arm_compute::ActivationLayerInfo(),
+                                 activationInfo,
                                  isFastMathEnabled);
 
     m_ConvolutionMethod =
@@ -107,7 +113,7 @@
                                                   output.info(),
                                                   padStrideInfo,
                                                   arm_compute::WeightsInfo(),
-                                                  arm_compute::ActivationLayerInfo(),
+                                                  activationInfo,
                                                   arm_compute::CLScheduler::get().target(),
                                                   aclDilationInfo,
                                                   isFastMathEnabled);
diff --git a/src/backends/cl/workloads/ClConvolution2dWorkload.hpp b/src/backends/cl/workloads/ClConvolution2dWorkload.hpp
index f769422..70170b5 100644
--- a/src/backends/cl/workloads/ClConvolution2dWorkload.hpp
+++ b/src/backends/cl/workloads/ClConvolution2dWorkload.hpp
@@ -23,7 +23,8 @@
                                                     const Convolution2dDescriptor& descriptor,
                                                     const TensorInfo& weights,
                                                     const Optional<TensorInfo>& biases,
-                                                    bool isFastMathEnabled = false);
+                                                    bool isFastMathEnabled = false,
+                                                    const ActivationDescriptor* activationDescriptor = nullptr);
 
 class ClConvolution2dWorkload : public BaseWorkload<Convolution2dQueueDescriptor>
 {
diff --git a/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp b/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp
index 8704b12..53f1684 100644
--- a/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp
+++ b/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp
@@ -8,11 +8,13 @@
 #include <ResolveType.hpp>
 #include "ClWorkloadUtils.hpp"
 
+#include <armnn/Exceptions.hpp>
 #include <aclCommon/ArmComputeUtils.hpp>
 #include <aclCommon/ArmComputeTensorUtils.hpp>
 #include <cl/ClTensorHandle.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
 #include <backendsCommon/WorkloadUtils.hpp>
+#include <backendsCommon/WorkloadData.hpp>
 
 #include <arm_compute/runtime/CL/functions/CLDepthwiseConvolutionLayer.h>
 
@@ -25,7 +27,8 @@
                                                            const TensorInfo& output,
                                                            const DepthwiseConvolution2dDescriptor& descriptor,
                                                            const TensorInfo& weights,
-                                                           const Optional<TensorInfo>& biases)
+                                                           const Optional<TensorInfo>& biases,
+                                                           const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input,  descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
@@ -56,13 +59,16 @@
             descriptor.m_DilationX,
             descriptor.m_DilationY);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::CLDepthwiseConvolutionLayer::validate(&aclInputInfo,
                                                               &aclWeightsInfo,
                                                               optionalAclBiasesInfo,
                                                               &aclOutputInfo,
                                                               aclPadStrideInfo,
                                                               aclDepthMultiplier,
-                                                              arm_compute::ActivationLayerInfo(),
+                                                              activationInfo,
                                                               aclDilationInfo);
 
 }
@@ -114,6 +120,8 @@
 
     arm_compute::PadStrideInfo padStrideInfo = BuildArmComputePadStrideInfo(m_Data.m_Parameters);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     m_DepthwiseConvolutionLayer = std::make_unique<arm_compute::CLDepthwiseConvolutionLayer>();
     static_cast<arm_compute::CLDepthwiseConvolutionLayer*>(m_DepthwiseConvolutionLayer.get())->configure(
         &input,
@@ -122,7 +130,7 @@
         &output,
         padStrideInfo,
         depthMultiplier,
-        arm_compute::ActivationLayerInfo(),
+        activationInfo,
         aclDilationInfo);
 
     ARMNN_ASSERT(m_DepthwiseConvolutionLayer);
diff --git a/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.hpp b/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.hpp
index fc277b9..c759137 100644
--- a/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.hpp
+++ b/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.hpp
@@ -18,7 +18,8 @@
                                                            const TensorInfo& output,
                                                            const DepthwiseConvolution2dDescriptor& descriptor,
                                                            const TensorInfo& weights,
-                                                           const Optional<TensorInfo>& biases);
+                                                           const Optional<TensorInfo>& biases,
+                                                           const ActivationDescriptor* activationDescriptor = nullptr);
 
 class ClDepthwiseConvolutionWorkload : public BaseWorkload<DepthwiseConvolution2dQueueDescriptor>
 {
diff --git a/src/backends/cl/workloads/ClDivisionFloatWorkload.cpp b/src/backends/cl/workloads/ClDivisionFloatWorkload.cpp
index 2a27f8a..c79e55e 100644
--- a/src/backends/cl/workloads/ClDivisionFloatWorkload.cpp
+++ b/src/backends/cl/workloads/ClDivisionFloatWorkload.cpp
@@ -4,9 +4,12 @@
 //
 
 #include "ClDivisionFloatWorkload.hpp"
-#include <cl/ClTensorHandle.hpp>
+
+#include <aclCommon/ArmComputeUtils.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
 
+#include <cl/ClTensorHandle.hpp>
+
 #include "ClWorkloadUtils.hpp"
 
 namespace armnn
@@ -14,13 +17,17 @@
 
 arm_compute::Status ClDivisionWorkloadValidate(const TensorInfo& input0,
                                                const TensorInfo& input1,
-                                               const TensorInfo& output)
+                                               const TensorInfo& output,
+                                               const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
-    return arm_compute::CLArithmeticDivision::validate(&aclInput1, &aclInput2, &aclOutput);
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
+    return arm_compute::CLArithmeticDivision::validate(&aclInput1, &aclInput2, &aclOutput, activationInfo);
 }
 
 
@@ -33,8 +40,10 @@
     arm_compute::ICLTensor& input0 = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
     arm_compute::ICLTensor& input1 = static_cast<IClTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
     arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
-    // Construct
-    m_ArithmeticDivision.configure(&input0, &input1, &output);
+
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
+    m_ArithmeticDivision.configure(&input0, &input1, &output, activationInfo);
 }
 
 void ClDivisionFloatWorkload::Execute() const
diff --git a/src/backends/cl/workloads/ClDivisionFloatWorkload.hpp b/src/backends/cl/workloads/ClDivisionFloatWorkload.hpp
index ddca87d..71d27ed 100644
--- a/src/backends/cl/workloads/ClDivisionFloatWorkload.hpp
+++ b/src/backends/cl/workloads/ClDivisionFloatWorkload.hpp
@@ -14,7 +14,8 @@
 
 arm_compute::Status ClDivisionWorkloadValidate(const TensorInfo& input0,
                                                const TensorInfo& input1,
-                                               const TensorInfo& output);
+                                               const TensorInfo& output,
+                                               const ActivationDescriptor* activationDescriptor = nullptr);
 
 class ClDivisionFloatWorkload : public FloatWorkload<DivisionQueueDescriptor>
 {
diff --git a/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp b/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp
index 60eb138..eaec639 100644
--- a/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp
+++ b/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp
@@ -20,7 +20,8 @@
                                                      const TensorInfo& output,
                                                      const TensorInfo& weights,
                                                      const TensorInfo& biases,
-                                                     const FullyConnectedDescriptor& descriptor)
+                                                     const FullyConnectedDescriptor& descriptor,
+                                                     const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output);
@@ -35,7 +36,7 @@
     }
 
     const arm_compute::FullyConnectedLayerInfo fullyConnectedLayerInfo =
-        ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor);
+        ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor, activationDescriptor);
 
     return arm_compute::CLFullyConnectedLayer::validate(&aclInput,
                                                         &aclWeights,
@@ -63,9 +64,11 @@
     arm_compute::ICLTensor& input  = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
     arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
 
-    // Construct
-    arm_compute::FullyConnectedLayerInfo fc_info;
-    fc_info.transpose_weights = m_Data.m_Parameters.m_TransposeWeightMatrix;
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
+    arm_compute::FullyConnectedLayerInfo fc_info =
+            ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor.m_Parameters, activationInfo);
+
     m_FullyConnectedLayer.configure(&input, m_WeightsTensor.get(), m_BiasesTensor.get(), &output, fc_info);
 
     InitializeArmComputeClTensorData(*m_WeightsTensor, m_Data.m_Weight);
diff --git a/src/backends/cl/workloads/ClFullyConnectedWorkload.hpp b/src/backends/cl/workloads/ClFullyConnectedWorkload.hpp
index e13436e..311b594 100644
--- a/src/backends/cl/workloads/ClFullyConnectedWorkload.hpp
+++ b/src/backends/cl/workloads/ClFullyConnectedWorkload.hpp
@@ -19,7 +19,8 @@
                                                      const TensorInfo& output,
                                                      const TensorInfo& weights,
                                                      const TensorInfo& biases,
-                                                     const FullyConnectedDescriptor& descriptor);
+                                                     const FullyConnectedDescriptor& descriptor,
+                                                     const ActivationDescriptor* activationDescriptor = nullptr);
 
 class ClFullyConnectedWorkload : public armnn::BaseWorkload<armnn::FullyConnectedQueueDescriptor>
 {
diff --git a/src/backends/cl/workloads/ClMultiplicationWorkload.cpp b/src/backends/cl/workloads/ClMultiplicationWorkload.cpp
index e9b75c3..46a1c4b 100644
--- a/src/backends/cl/workloads/ClMultiplicationWorkload.cpp
+++ b/src/backends/cl/workloads/ClMultiplicationWorkload.cpp
@@ -4,8 +4,12 @@
 //
 
 #include "ClMultiplicationWorkload.hpp"
-#include <cl/ClTensorHandle.hpp>
+
+#include <aclCommon/ArmComputeUtils.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
+
+#include <cl/ClTensorHandle.hpp>
+
 #include "ClWorkloadUtils.hpp"
 
 namespace armnn
@@ -13,7 +17,8 @@
 
 arm_compute::Status ClMultiplicationWorkloadValidate(const TensorInfo& input0,
                                                      const TensorInfo& input1,
-                                                     const TensorInfo& output)
+                                                     const TensorInfo& output,
+                                                     const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
@@ -23,6 +28,9 @@
                           arm_compute::ConvertPolicy::SATURATE :
                           arm_compute::ConvertPolicy::WRAP;
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     // At the time of writing, configure() will fail if a rounding policy other than TO_ZERO is supplied to it,
     // when providing a scale of 1.0 for F32 tensors, even though the provided rounding policy appears to be
     // ignored for F32 tensors.
@@ -31,7 +39,8 @@
                                                             &aclOutput,
                                                             1.0f,
                                                             convertPolicy,
-                                                            arm_compute::RoundingPolicy::TO_ZERO);
+                                                            arm_compute::RoundingPolicy::TO_ZERO,
+                                                            activationInfo);
 }
 
 
@@ -50,13 +59,16 @@
                           arm_compute::ConvertPolicy::SATURATE :
                           arm_compute::ConvertPolicy::WRAP;
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     // Construct
     m_PixelWiseMultiplication.configure(&input0,
                                         &input1,
                                         &output,
                                         1.0f,
                                         convertPolicy,
-                                        arm_compute::RoundingPolicy::TO_NEAREST_EVEN);
+                                        arm_compute::RoundingPolicy::TO_NEAREST_EVEN,
+                                        activationInfo);
 }
 
 void ClMultiplicationWorkload::Execute() const
diff --git a/src/backends/cl/workloads/ClMultiplicationWorkload.hpp b/src/backends/cl/workloads/ClMultiplicationWorkload.hpp
index 732bb16..461449c 100644
--- a/src/backends/cl/workloads/ClMultiplicationWorkload.hpp
+++ b/src/backends/cl/workloads/ClMultiplicationWorkload.hpp
@@ -14,7 +14,8 @@
 
 arm_compute::Status ClMultiplicationWorkloadValidate(const TensorInfo& input0,
                                                      const TensorInfo& input1,
-                                                     const TensorInfo& output);
+                                                     const TensorInfo& output,
+                                                     const ActivationDescriptor* activationDescriptor = nullptr);
 
 class ClMultiplicationWorkload : public BaseWorkload<MultiplicationQueueDescriptor>
 {
diff --git a/src/backends/cl/workloads/ClSubtractionWorkload.cpp b/src/backends/cl/workloads/ClSubtractionWorkload.cpp
index 38154eb..c9fb556 100644
--- a/src/backends/cl/workloads/ClSubtractionWorkload.cpp
+++ b/src/backends/cl/workloads/ClSubtractionWorkload.cpp
@@ -7,9 +7,11 @@
 
 #include <cl/ClTensorHandle.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
 #include <aclCommon/ArmComputeTensorUtils.hpp>
 
 #include "ClWorkloadUtils.hpp"
+#include "../../../../include/armnn/ArmNN.hpp"
 
 namespace armnn
 {
@@ -26,7 +28,10 @@
     arm_compute::ICLTensor& input0 = static_cast<IClTensorHandle*>(this->m_Data.m_Inputs[0])->GetTensor();
     arm_compute::ICLTensor& input1 = static_cast<IClTensorHandle*>(this->m_Data.m_Inputs[1])->GetTensor();
     arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(this->m_Data.m_Outputs[0])->GetTensor();
-    m_Layer.configure(&input0, &input1, &output, g_AclConvertPolicy);
+
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
+    m_Layer.configure(&input0, &input1, &output, g_AclConvertPolicy, activationInfo);
 }
 
 void ClSubtractionWorkload::Execute() const
@@ -37,16 +42,21 @@
 
 arm_compute::Status ClSubtractionValidate(const TensorInfo& input0,
                                           const TensorInfo& input1,
-                                          const TensorInfo& output)
+                                          const TensorInfo& output,
+                                          const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput0Info = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1Info = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     const arm_compute::Status aclStatus = arm_compute::CLArithmeticSubtraction::validate(&aclInput0Info,
                                                                                          &aclInput1Info,
                                                                                          &aclOutputInfo,
-                                                                                         g_AclConvertPolicy);
+                                                                                         g_AclConvertPolicy,
+                                                                                         activationInfo);
 
     return aclStatus;
 }
diff --git a/src/backends/cl/workloads/ClSubtractionWorkload.hpp b/src/backends/cl/workloads/ClSubtractionWorkload.hpp
index da6d17c..9f51de6 100644
--- a/src/backends/cl/workloads/ClSubtractionWorkload.hpp
+++ b/src/backends/cl/workloads/ClSubtractionWorkload.hpp
@@ -25,5 +25,6 @@
 
 arm_compute::Status ClSubtractionValidate(const TensorInfo& input0,
                                           const TensorInfo& input1,
-                                          const TensorInfo& output);
+                                          const TensorInfo& output,
+                                          const ActivationDescriptor* activationDescriptor = nullptr);
 } //namespace armnn
diff --git a/src/backends/neon/NeonBackend.cpp b/src/backends/neon/NeonBackend.cpp
index 9862ddb..150bc34 100644
--- a/src/backends/neon/NeonBackend.cpp
+++ b/src/backends/neon/NeonBackend.cpp
@@ -11,7 +11,10 @@
 #include "NeonTensorHandleFactory.hpp"
 
 #include <armnn/BackendRegistry.hpp>
+#include <armnn/Descriptors.hpp>
 
+#include <aclCommon/ArmComputeSubgraphUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
 #include <aclCommon/BaseMemoryManager.hpp>
 
 #include <armnn/backends/IBackendContext.hpp>
@@ -19,8 +22,18 @@
 
 #include <armnn/utility/PolymorphicDowncast.hpp>
 
+#include "workloads/NeonAdditionWorkload.hpp"
+#include "workloads/NeonBatchNormalizationWorkload.hpp"
+#include "workloads/NeonConvolution2dWorkload.hpp"
+#include "workloads/NeonDepthwiseConvolutionWorkload.hpp"
+#include "workloads/NeonDivisionWorkload.hpp"
+#include "workloads/NeonFullyConnectedWorkload.hpp"
+#include "workloads/NeonMultiplicationWorkload.hpp"
+#include "workloads/NeonSubtractionWorkload.hpp"
+
 #include <Optimizer.hpp>
 
+#include <arm_compute/core/Types.h>
 #include <arm_compute/runtime/Allocator.h>
 
 namespace armnn
@@ -122,7 +135,238 @@
 {
     OptimizationViews optimizationViews;
 
-    optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
+    auto it = subgraph.end();
+
+    while (it != subgraph.begin())
+    {
+        --it;
+        Layer& base = **it;
+
+        if ((base.GetType() == LayerType::DepthwiseConvolution2d || base.GetType() == LayerType::Convolution2d
+             || base.GetType() == LayerType::BatchNormalization || base.GetType() == LayerType::FullyConnected
+             || base.GetType() == LayerType::Addition || base.GetType() == LayerType::Multiplication
+             || base.GetType() == LayerType::Subtraction || base.GetType() == LayerType::Division)
+            && (base.GetAdditionalInformation<ActivationDescriptor>() == nullptr))
+        {
+            for (auto output = base.BeginOutputSlots(); output != base.EndOutputSlots(); ++output)
+            {
+                if (output->GetNumConnections() == 1)
+                {
+                    for (auto&& childInput : output->GetConnections())
+                    {
+                        if (childInput->GetOwningLayer().GetType() == LayerType::Activation)
+                        {
+                            Layer& child = childInput->GetOwningLayer();
+
+                            auto* activationLayer = PolymorphicDowncast<ActivationLayer*>(&child);
+
+                            const std::string name = std::string("fused-") + child.GetName() + std::string("-into-") +
+                                                     base.GetName();
+
+                            // Get params from activation layer
+                            ActivationDescriptor activationDesc = activationLayer->GetParameters();
+
+                            if (base.GetType() == LayerType::Convolution2d)
+                            {
+                                Convolution2dLayer* baseLayer = PolymorphicDowncast<Convolution2dLayer*>(&base);
+
+                                Optional<TensorInfo> biases;
+
+                                if (baseLayer->GetParameters().m_BiasEnabled)
+                                {
+                                    biases = GetOverriddenDataType(baseLayer->m_Bias->GetTensorInfo(),
+                                            GetOptionalBiasTypeFromWeightsType(
+                                                    baseLayer->m_Weight->GetTensorInfo().GetDataType()));
+                                }
+
+                                arm_compute::Status status = NeonConvolution2dWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        baseLayer->m_Weight->GetTensorInfo(),
+                                        biases,
+                                        false,
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithWeightsAndBiases<Convolution2dLayer>(optimizationViews,
+                                                                                      baseLayer,
+                                                                                      activationLayer,
+                                                                                      activationDesc,
+                                                                                      name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::DepthwiseConvolution2d)
+                            {
+                                DepthwiseConvolution2dLayer* baseLayer =
+                                        PolymorphicDowncast<DepthwiseConvolution2dLayer*>(&base);
+
+                                Optional<TensorInfo> biases;
+
+                                if (baseLayer->GetParameters().m_BiasEnabled)
+                                {
+                                    biases = GetOverriddenDataType(baseLayer->m_Bias->GetTensorInfo(),
+                                            GetOptionalBiasTypeFromWeightsType(
+                                                    baseLayer->m_Weight->GetTensorInfo().GetDataType()));
+                                }
+
+                                arm_compute::Status status = NeonDepthwiseConvolutionWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        baseLayer->m_Weight->GetTensorInfo(),
+                                        biases,
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithWeightsAndBiases<DepthwiseConvolution2dLayer>(optimizationViews,
+                                                                                               baseLayer,
+                                                                                               activationLayer,
+                                                                                               activationDesc,
+                                                                                               name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::FullyConnected)
+                            {
+                                FullyConnectedLayer* baseLayer = PolymorphicDowncast<FullyConnectedLayer*>(&base);
+
+                                arm_compute::Status status = NeonFullyConnectedWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->m_Weight->GetTensorInfo(),
+                                        baseLayer->m_Bias->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithWeightsAndBiases<FullyConnectedLayer>(optimizationViews,
+                                                                                       baseLayer,
+                                                                                       activationLayer,
+                                                                                       activationDesc,
+                                                                                       name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::BatchNormalization)
+                            {
+                                BatchNormalizationLayer* baseLayer =
+                                        PolymorphicDowncast<BatchNormalizationLayer*>(&base);
+
+                                arm_compute::Status status = NeonBatchNormalizationValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->m_Mean->GetTensorInfo(),
+                                        baseLayer->m_Variance->GetTensorInfo(),
+                                        baseLayer->m_Beta->GetTensorInfo(),
+                                        baseLayer->m_Gamma->GetTensorInfo(),
+                                        baseLayer->GetParameters(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    BatchNormalizationLayer* replacementLayer =
+                                            FuseLayerWithParameters<BatchNormalizationLayer>(
+                                                    optimizationViews,
+                                                    baseLayer,
+                                                    activationLayer,
+                                                    activationDesc,
+                                                    name);
+
+                                    replacementLayer->m_Beta     = std::move(baseLayer->m_Beta);
+                                    replacementLayer->m_Gamma    = std::move(baseLayer->m_Gamma);
+                                    replacementLayer->m_Mean     = std::move(baseLayer->m_Mean);
+                                    replacementLayer->m_Variance = std::move(baseLayer->m_Variance);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Addition)
+                            {
+                                AdditionLayer* baseLayer = PolymorphicDowncast<AdditionLayer*>(&base);
+
+                                arm_compute::Status status = NeonAdditionWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<AdditionLayer>(optimizationViews,
+                                                                              baseLayer,
+                                                                              activationLayer,
+                                                                              activationDesc,
+                                                                              name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Division)
+                            {
+                                DivisionLayer* baseLayer = PolymorphicDowncast<DivisionLayer*>(&base);
+
+                                arm_compute::Status status = NeonDivisionWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<DivisionLayer>(optimizationViews,
+                                                                              baseLayer,
+                                                                              activationLayer,
+                                                                              activationDesc,
+                                                                              name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Multiplication)
+                            {
+                                MultiplicationLayer* baseLayer = PolymorphicDowncast<MultiplicationLayer*>(&base);
+
+                                arm_compute::Status status = NeonMultiplicationWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<MultiplicationLayer>(optimizationViews,
+                                                                                    baseLayer,
+                                                                                    activationLayer,
+                                                                                    activationDesc,
+                                                                                    name);
+                                }
+                            }
+                            else if (base.GetType() == LayerType::Subtraction)
+                            {
+                                SubtractionLayer* baseLayer = PolymorphicDowncast<SubtractionLayer*>(&base);
+
+                                arm_compute::Status status = NeonSubtractionWorkloadValidate(
+                                        baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
+                                        &activationDesc);
+
+                                if (status)
+                                {
+                                    FuseLayerWithoutParameters<SubtractionLayer>(optimizationViews,
+                                                                                 baseLayer,
+                                                                                 activationLayer,
+                                                                                 activationDesc,
+                                                                                 name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (optimizationViews.GetSubstitutions().empty())
+    {
+        optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
+    }
 
     return optimizationViews;
 }
diff --git a/src/backends/neon/NeonLayerSupport.cpp b/src/backends/neon/NeonLayerSupport.cpp
index 0084dbd..f55d1c8 100644
--- a/src/backends/neon/NeonLayerSupport.cpp
+++ b/src/backends/neon/NeonLayerSupport.cpp
@@ -167,7 +167,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsArgMinMaxSupported(const TensorInfo& input,
@@ -199,7 +200,8 @@
                                    var,
                                    beta,
                                    gamma,
-                                   descriptor);
+                                   descriptor,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
@@ -345,7 +347,8 @@
                                    descriptor,
                                    weights,
                                    biases,
-                                   isFastMathEnabled);
+                                   isFastMathEnabled,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
@@ -373,7 +376,8 @@
                                    output,
                                    descriptor,
                                    weights,
-                                   biases);
+                                   biases,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsDequantizeSupported(const TensorInfo& input,
@@ -399,7 +403,8 @@
                                    output,
                                    descriptor,
                                    weights,
-                                   biases);
+                                   biases,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
@@ -474,7 +479,8 @@
                                    output,
                                    weights,
                                    biases,
-                                   descriptor);
+                                   descriptor,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsGatherSupported(const TensorInfo& input0,
@@ -611,7 +617,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsDivisionSupported(const TensorInfo& input0,
@@ -623,7 +630,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsNormalizationSupported(const TensorInfo& input,
@@ -911,7 +919,8 @@
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
-                                   output);
+                                   output,
+                                   nullptr);
 }
 
 bool NeonLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input,
diff --git a/src/backends/neon/workloads/NeonAdditionWorkload.cpp b/src/backends/neon/workloads/NeonAdditionWorkload.cpp
index cb0c8a4..9300b31 100644
--- a/src/backends/neon/workloads/NeonAdditionWorkload.cpp
+++ b/src/backends/neon/workloads/NeonAdditionWorkload.cpp
@@ -7,6 +7,8 @@
 #include "NeonWorkloadUtils.hpp"
 
 #include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+
 #include <armnn/utility/PolymorphicDowncast.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
 
@@ -17,16 +19,21 @@
 
 arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo& input0,
                                                  const TensorInfo& input1,
-                                                 const TensorInfo& output)
+                                                 const TensorInfo& output,
+                                                 const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::NEArithmeticAddition::validate(&aclInput0,
                                                        &aclInput1,
                                                        &aclOutput,
-                                                       arm_compute::ConvertPolicy::SATURATE);
+                                                       arm_compute::ConvertPolicy::SATURATE,
+                                                       activationInfo);
 }
 
 
@@ -40,8 +47,10 @@
     arm_compute::ITensor& input2 = PolymorphicDowncast<IAclTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
     arm_compute::ITensor& output = PolymorphicDowncast<IAclTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     auto layer = std::make_unique<arm_compute::NEArithmeticAddition>();
-    layer->configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE);
+    layer->configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE, activationInfo);
     m_AddLayer.reset(layer.release());
 }
 
diff --git a/src/backends/neon/workloads/NeonAdditionWorkload.hpp b/src/backends/neon/workloads/NeonAdditionWorkload.hpp
index 826fb1f..8e43cbd 100644
--- a/src/backends/neon/workloads/NeonAdditionWorkload.hpp
+++ b/src/backends/neon/workloads/NeonAdditionWorkload.hpp
@@ -8,6 +8,7 @@
 #include <backendsCommon/Workload.hpp>
 
 #include <arm_compute/core/Error.h>
+#include <arm_compute/core/Types.h>
 #include <arm_compute/runtime/IFunction.h>
 
 namespace armnn
@@ -15,7 +16,8 @@
 
 arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo& input0,
                                                  const TensorInfo& input1,
-                                                 const TensorInfo& output);
+                                                 const TensorInfo& output,
+                                                 const ActivationDescriptor* activationDescriptor = nullptr);
 
 class NeonAdditionWorkload : public BaseWorkload<AdditionQueueDescriptor>
 {
diff --git a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp
index ff777db..33480fa 100644
--- a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp
+++ b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp
@@ -8,7 +8,10 @@
 #include "NeonWorkloadUtils.hpp"
 
 #include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+
 #include <armnn/utility/PolymorphicDowncast.hpp>
+
 #include <backendsCommon/CpuTensorHandle.hpp>
 
 #include <arm_compute/runtime/NEON/functions/NEBatchNormalizationLayer.h>
@@ -24,7 +27,8 @@
                                                    const TensorInfo& var,
                                                    const TensorInfo& beta,
                                                    const TensorInfo& gamma,
-                                                   const BatchNormalizationDescriptor& descriptor)
+                                                   const BatchNormalizationDescriptor& descriptor,
+                                                   const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInputInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
@@ -39,13 +43,17 @@
     const arm_compute::TensorInfo aclGammaInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(gamma, descriptor.m_DataLayout);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::NEBatchNormalizationLayer::validate(&aclInputInfo,
                                                             &aclOutputInfo,
                                                             &aclMeanInfo,
                                                             &aclVarInfo,
                                                             &aclBetaInfo,
                                                             &aclGammaInfo,
-                                                            descriptor.m_Eps);
+                                                            descriptor.m_Eps,
+                                                            activationInfo);
 }
 
 NeonBatchNormalizationWorkload::NeonBatchNormalizationWorkload(
@@ -73,6 +81,8 @@
     m_Beta = std::make_unique<arm_compute::Tensor>();
     BuildArmComputeTensor(*m_Beta, m_Data.m_Beta->GetTensorInfo());
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     auto layer = std::make_unique<arm_compute::NEBatchNormalizationLayer>();
     layer->configure(&input,
                      &output,
@@ -80,7 +90,8 @@
                      m_Variance.get(),
                      m_Beta.get(),
                      m_Gamma.get(),
-                     m_Data.m_Parameters.m_Eps);
+                     m_Data.m_Parameters.m_Eps,
+                     activationInfo);
     m_Layer.reset(layer.release());
 
     InitializeArmComputeTensorData(*m_Mean, m_Data.m_Mean);
diff --git a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp
index 3619ea0..fea778f 100644
--- a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp
+++ b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp
@@ -21,7 +21,8 @@
                                                    const TensorInfo& var,
                                                    const TensorInfo& beta,
                                                    const TensorInfo& gamma,
-                                                   const BatchNormalizationDescriptor& descriptor);
+                                                   const BatchNormalizationDescriptor& descriptor,
+                                                   const ActivationDescriptor* activationDescriptor = nullptr);
 
 class NeonBatchNormalizationWorkload : public BaseWorkload<BatchNormalizationQueueDescriptor>
 {
diff --git a/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp
index af6f1ae..fd8be17 100644
--- a/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp
+++ b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp
@@ -6,6 +6,7 @@
 #include "NeonConvolution2dWorkload.hpp"
 
 #include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
 #include <armnn/utility/PolymorphicDowncast.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
 #include <neon/workloads/NeonWorkloadUtils.hpp>
@@ -25,7 +26,8 @@
                                                       const Convolution2dDescriptor& descriptor,
                                                       const TensorInfo& weights,
                                                       const Optional<TensorInfo>& biases,
-                                                      bool isFastMathEnabled)
+                                                      bool isFastMathEnabled,
+                                                      const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
@@ -47,6 +49,9 @@
 
     arm_compute::PadStrideInfo layerInfo = BuildArmComputePadStrideInfo(descriptor);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::NEConvolutionLayer::validate(&aclInputInfo,
                                                      &aclWeightsInfo,
                                                      optionalAclBiasesInfo,
@@ -54,7 +59,7 @@
                                                      layerInfo,
                                                      arm_compute::WeightsInfo(),
                                                      aclDilationInfo,
-                                                     arm_compute::ActivationLayerInfo(),
+                                                     activationInfo,
                                                      isFastMathEnabled);
 }
 
@@ -92,6 +97,8 @@
     const arm_compute::Size2D aclDilationInfo = BuildArmComputeSize2D(m_Data.m_Parameters.m_DilationX,
                                                                       m_Data.m_Parameters.m_DilationY);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     auto convolutionLayer = std::make_unique<arm_compute::NEConvolutionLayer>(memoryManager);
     convolutionLayer->configure(&input,
                                 m_KernelTensor.get(),
@@ -100,7 +107,7 @@
                                 padStrideInfo,
                                 arm_compute::WeightsInfo(),
                                 aclDilationInfo,
-                                arm_compute::ActivationLayerInfo(),
+                                activationInfo,
                                 isFastMathEnabled);
 
     m_ConvolutionMethod =
@@ -110,7 +117,7 @@
                                                  padStrideInfo,
                                                  arm_compute::WeightsInfo(),
                                                  aclDilationInfo,
-                                                 arm_compute::ActivationLayerInfo(),
+                                                 activationInfo,
                                                  isFastMathEnabled);
 
     m_ConvolutionLayer.reset(convolutionLayer.release());
diff --git a/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp b/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp
index 860d78b..4b6e58c 100644
--- a/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp
+++ b/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp
@@ -21,7 +21,8 @@
                                                       const Convolution2dDescriptor& descriptor,
                                                       const TensorInfo& weights,
                                                       const Optional<TensorInfo>& biases,
-                                                      bool isFastMathEnabled = false);
+                                                      bool isFastMathEnabled = false,
+                                                      const ActivationDescriptor* activationDescriptor = nullptr);
 
 class NeonConvolution2dWorkload : public BaseWorkload<Convolution2dQueueDescriptor>
 {
diff --git a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp
index a9a3c75..db6bcc3 100644
--- a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp
+++ b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp
@@ -10,6 +10,7 @@
 #include <armnnUtils/DataLayoutIndexed.hpp>
 
 #include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
 
 #include <neon/NeonLayerSupport.hpp>
 
@@ -29,7 +30,8 @@
                                                              const TensorInfo& output,
                                                              const DepthwiseConvolution2dDescriptor& descriptor,
                                                              const TensorInfo& weights,
-                                                             const Optional<TensorInfo>& biases)
+                                                             const Optional<TensorInfo>& biases,
+                                                             const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input,  descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
@@ -59,13 +61,16 @@
     const arm_compute::Size2D aclDilationInfo = BuildArmComputeSize2D(
             descriptor.m_DilationX,descriptor.m_DilationY);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::NEDepthwiseConvolutionLayer::validate(&aclInputInfo,
                                                               &aclWeightsInfo,
                                                               optionalAclBiasesInfo,
                                                               &aclOutputInfo,
                                                               aclPadStrideInfo,
                                                               aclDepthMultiplier,
-                                                              arm_compute::ActivationLayerInfo(),
+                                                              activationInfo,
                                                               aclDilationInfo);
 }
 
@@ -116,16 +121,18 @@
 
     arm_compute::PadStrideInfo padStrideInfo = BuildArmComputePadStrideInfo(m_Data.m_Parameters);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     m_pDepthwiseConvolutionLayer = std::make_unique<arm_compute::NEDepthwiseConvolutionLayer>();
     static_cast<arm_compute::NEDepthwiseConvolutionLayer*>(
         m_pDepthwiseConvolutionLayer.get())->configure(&input,
-                                                        m_KernelTensor.get(),
-                                                        m_BiasTensor.get(),
-                                                        &output,
-                                                        padStrideInfo,
-                                                        depthMultiplier,
-                                                        arm_compute::ActivationLayerInfo(),
-                                                        aclDilationInfo);
+                                                       m_KernelTensor.get(),
+                                                       m_BiasTensor.get(),
+                                                       &output,
+                                                       padStrideInfo,
+                                                       depthMultiplier,
+                                                       activationInfo,
+                                                       aclDilationInfo);
 
     ARMNN_ASSERT(m_pDepthwiseConvolutionLayer);
 
diff --git a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp
index 85932d3..d257b91 100644
--- a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp
+++ b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp
@@ -19,7 +19,9 @@
                                                              const TensorInfo& output,
                                                              const DepthwiseConvolution2dDescriptor& descriptor,
                                                              const TensorInfo& weights,
-                                                             const Optional<TensorInfo>& biases);
+                                                             const Optional<TensorInfo>& biases,
+                                                             const ActivationDescriptor* activationDescriptor
+                                                                     = nullptr);
 
 class NeonDepthwiseConvolutionWorkload : public BaseWorkload<DepthwiseConvolution2dQueueDescriptor>
 {
diff --git a/src/backends/neon/workloads/NeonDivisionWorkload.cpp b/src/backends/neon/workloads/NeonDivisionWorkload.cpp
index fc353f1..1a26d95 100644
--- a/src/backends/neon/workloads/NeonDivisionWorkload.cpp
+++ b/src/backends/neon/workloads/NeonDivisionWorkload.cpp
@@ -6,23 +6,31 @@
 #include "NeonDivisionWorkload.hpp"
 
 #include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+
 #include <armnn/utility/PolymorphicDowncast.hpp>
+
 #include <backendsCommon/CpuTensorHandle.hpp>
 
 namespace armnn
 {
 
 arm_compute::Status NeonDivisionWorkloadValidate(const TensorInfo& input0,
-                                                const TensorInfo& input1,
-                                                const TensorInfo& output)
+                                                 const TensorInfo& input1,
+                                                 const TensorInfo& output,
+                                                 const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::NEElementwiseDivision::validate(&aclInput0,
-                                                   &aclInput1,
-                                                   &aclOutput);
+                                                        &aclInput1,
+                                                        &aclOutput,
+                                                        activationInfo);
 }
 
 NeonDivisionWorkload::NeonDivisionWorkload(const DivisionQueueDescriptor& descriptor,
@@ -35,7 +43,9 @@
     arm_compute::ITensor& input1 = PolymorphicDowncast<IAclTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
     arm_compute::ITensor& output = PolymorphicDowncast<IAclTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
 
-    m_DivLayer.configure(&input0, &input1, &output);
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
+    m_DivLayer.configure(&input0, &input1, &output, activationInfo);
 }
 
 void NeonDivisionWorkload::Execute() const
diff --git a/src/backends/neon/workloads/NeonDivisionWorkload.hpp b/src/backends/neon/workloads/NeonDivisionWorkload.hpp
index 2405d9a..fffe02f 100644
--- a/src/backends/neon/workloads/NeonDivisionWorkload.hpp
+++ b/src/backends/neon/workloads/NeonDivisionWorkload.hpp
@@ -13,8 +13,9 @@
 {
 
 arm_compute::Status NeonDivisionWorkloadValidate(const TensorInfo& input0,
-                                                const TensorInfo& input1,
-                                                const TensorInfo& output);
+                                                 const TensorInfo& input1,
+                                                 const TensorInfo& output,
+                                                 const ActivationDescriptor* activationDescriptor = nullptr);
 
 class NeonDivisionWorkload : public BaseWorkload<DivisionQueueDescriptor>
 {
diff --git a/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp b/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp
index e808c60..31489a0 100644
--- a/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp
+++ b/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp
@@ -6,9 +6,12 @@
 #include "NeonFullyConnectedWorkload.hpp"
 
 #include "NeonWorkloadUtils.hpp"
+
 #include <aclCommon/ArmComputeTensorUtils.hpp>
 #include <aclCommon/ArmComputeUtils.hpp>
+
 #include <armnn/utility/PolymorphicDowncast.hpp>
+
 #include <backendsCommon/CpuTensorHandle.hpp>
 
 #include <arm_compute/runtime/NEON/functions/NEFullyConnectedLayer.h>
@@ -21,7 +24,8 @@
                                                        const TensorInfo& output,
                                                        const TensorInfo& weights,
                                                        const TensorInfo& biases,
-                                                       const FullyConnectedDescriptor& descriptor)
+                                                       const FullyConnectedDescriptor& descriptor,
+                                                       const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output);
@@ -36,8 +40,7 @@
     }
 
     const arm_compute::FullyConnectedLayerInfo fullyConnectedLayerInfo =
-        ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor);
-
+        ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor, activationDescriptor);
 
     return arm_compute::NEFullyConnectedLayer::validate(&aclInput,
                                                         &aclWeights,
@@ -64,9 +67,10 @@
         BuildArmComputeTensor(*m_BiasesTensor, m_Data.m_Bias->GetTensorInfo());
     }
 
-    // Construct
-    arm_compute::FullyConnectedLayerInfo fc_info;
-    fc_info.transpose_weights = m_Data.m_Parameters.m_TransposeWeightMatrix;
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
+    arm_compute::FullyConnectedLayerInfo fc_info  =
+            ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor.m_Parameters, activationInfo);
 
     auto layer = std::make_unique<arm_compute::NEFullyConnectedLayer>(memoryManager);
     layer->configure(&input, m_WeightsTensor.get(), m_BiasesTensor.get(), &output, fc_info);
diff --git a/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp b/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp
index 1cd8be1..8dc7fdc 100644
--- a/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp
+++ b/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp
@@ -21,7 +21,8 @@
                                                        const TensorInfo& output,
                                                        const TensorInfo& weights,
                                                        const TensorInfo& biases,
-                                                       const FullyConnectedDescriptor& descriptor);
+                                                       const FullyConnectedDescriptor& descriptor,
+                                                       const ActivationDescriptor* activationDescriptor = nullptr);
 
 class NeonFullyConnectedWorkload : public BaseWorkload<FullyConnectedQueueDescriptor>
 {
diff --git a/src/backends/neon/workloads/NeonMultiplicationWorkload.cpp b/src/backends/neon/workloads/NeonMultiplicationWorkload.cpp
index 6f78b8e..e4ed195 100644
--- a/src/backends/neon/workloads/NeonMultiplicationWorkload.cpp
+++ b/src/backends/neon/workloads/NeonMultiplicationWorkload.cpp
@@ -7,6 +7,8 @@
 
 #include "NeonWorkloadUtils.hpp"
 
+#include <aclCommon/ArmComputeUtils.hpp>
+
 #include <armnn/utility/PolymorphicDowncast.hpp>
 
 #include <arm_compute/runtime/NEON/functions/NEPixelWiseMultiplication.h>
@@ -16,7 +18,8 @@
 
 arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0,
                                                        const TensorInfo& input1,
-                                                       const TensorInfo& output)
+                                                       const TensorInfo& output,
+                                                       const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
@@ -26,6 +29,9 @@
                           arm_compute::ConvertPolicy::SATURATE :
                           arm_compute::ConvertPolicy::WRAP;
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     // At the time of writing, configure() will fail if a rounding policy other than TO_ZERO is supplied to it,
     // when providing a scale of 1.0 for F32 tensors, even though the provided rounding policy appears to be
     // ignored for F32 tensors.
@@ -34,7 +40,8 @@
                                                             &aclOutput,
                                                             1.0f,
                                                             convertPolicy,
-                                                            arm_compute::RoundingPolicy::TO_ZERO);
+                                                            arm_compute::RoundingPolicy::TO_ZERO,
+                                                            activationInfo);
 }
 
 NeonMultiplicationWorkload::NeonMultiplicationWorkload(const MultiplicationQueueDescriptor& descriptor,
@@ -52,6 +59,8 @@
                           arm_compute::ConvertPolicy::SATURATE :
                           arm_compute::ConvertPolicy::WRAP;
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     // At the time of writing, configure() will fail if a rounding policy other than TO_ZERO is supplied to it,
     // when providing a scale of 1.0 for F32 tensors, even though the provided rounding policy appears to be
     // ignored for F32 tensors.
@@ -61,7 +70,8 @@
                      &output,
                      1.0f,
                      convertPolicy,
-                     arm_compute::RoundingPolicy::TO_ZERO);
+                     arm_compute::RoundingPolicy::TO_ZERO,
+                     activationInfo);
     m_PixelWiseMultiplication.reset(layer.release());
 }
 
diff --git a/src/backends/neon/workloads/NeonMultiplicationWorkload.hpp b/src/backends/neon/workloads/NeonMultiplicationWorkload.hpp
index bfbaf77..d2bcd04 100644
--- a/src/backends/neon/workloads/NeonMultiplicationWorkload.hpp
+++ b/src/backends/neon/workloads/NeonMultiplicationWorkload.hpp
@@ -8,6 +8,7 @@
 #include <backendsCommon/Workload.hpp>
 
 #include <arm_compute/core/Error.h>
+#include <arm_compute/core/Types.h>
 #include <arm_compute/runtime/IFunction.h>
 
 #include <memory>
@@ -16,7 +17,8 @@
 {
 arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0,
                                                        const TensorInfo& input1,
-                                                       const TensorInfo& output);
+                                                       const TensorInfo& output,
+                                                       const ActivationDescriptor* activationDescriptor = nullptr);
 
 class NeonMultiplicationWorkload : public BaseWorkload<MultiplicationQueueDescriptor>
 {
diff --git a/src/backends/neon/workloads/NeonSubtractionWorkload.cpp b/src/backends/neon/workloads/NeonSubtractionWorkload.cpp
index ccc2bfe..21f0f6f 100644
--- a/src/backends/neon/workloads/NeonSubtractionWorkload.cpp
+++ b/src/backends/neon/workloads/NeonSubtractionWorkload.cpp
@@ -6,8 +6,12 @@
 #include "NeonSubtractionWorkload.hpp"
 
 #include "NeonWorkloadUtils.hpp"
+
 #include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+
 #include <armnn/utility/PolymorphicDowncast.hpp>
+
 #include <backendsCommon/CpuTensorHandle.hpp>
 
 #include <arm_compute/runtime/NEON/functions/NEArithmeticSubtraction.h>
@@ -17,16 +21,21 @@
 
 arm_compute::Status NeonSubtractionWorkloadValidate(const TensorInfo& input0,
                                                     const TensorInfo& input1,
-                                                    const TensorInfo& output)
+                                                    const TensorInfo& output,
+                                                    const ActivationDescriptor* activationDescriptor)
 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertActivationDescriptorToAclActivationLayerInfo(
+            activationDescriptor);
+
     return arm_compute::NEArithmeticSubtraction::validate(&aclInput0,
                                                           &aclInput1,
                                                           &aclOutput,
-                                                          arm_compute::ConvertPolicy::SATURATE);
+                                                          arm_compute::ConvertPolicy::SATURATE,
+                                                          activationInfo);
 }
 
 NeonSubtractionWorkload::NeonSubtractionWorkload(const SubtractionQueueDescriptor& descriptor,
@@ -39,8 +48,10 @@
     arm_compute::ITensor& input2 = PolymorphicDowncast<IAclTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
     arm_compute::ITensor& output = PolymorphicDowncast<IAclTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
 
+    const arm_compute::ActivationLayerInfo activationInfo = ConvertAdditionalInfoToAclActivationLayerInfo(descriptor);
+
     auto layer = std::make_unique<arm_compute::NEArithmeticSubtraction>();
-    layer->configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE);
+    layer->configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE, activationInfo);
     m_SubLayer.reset(layer.release());
 }
 
diff --git a/src/backends/neon/workloads/NeonSubtractionWorkload.hpp b/src/backends/neon/workloads/NeonSubtractionWorkload.hpp
index 3326f8b..19d0811 100644
--- a/src/backends/neon/workloads/NeonSubtractionWorkload.hpp
+++ b/src/backends/neon/workloads/NeonSubtractionWorkload.hpp
@@ -8,6 +8,7 @@
 #include <backendsCommon/Workload.hpp>
 
 #include <arm_compute/core/Error.h>
+#include <arm_compute/core/Types.h>
 #include <arm_compute/runtime/IFunction.h>
 
 #include <memory>
@@ -17,7 +18,8 @@
 
 arm_compute::Status NeonSubtractionWorkloadValidate(const TensorInfo& input0,
                                                     const TensorInfo& input1,
-                                                    const TensorInfo& output);
+                                                    const TensorInfo& output,
+                                                    const ActivationDescriptor* activationDescriptor = nullptr);
 
 class NeonSubtractionWorkload : public BaseWorkload<SubtractionQueueDescriptor>
 {
diff --git a/src/profiling/test/ProfilingTestUtils.cpp b/src/profiling/test/ProfilingTestUtils.cpp
index 09639bf..93d0b10 100644
--- a/src/profiling/test/ProfilingTestUtils.cpp
+++ b/src/profiling/test/ProfilingTestUtils.cpp
@@ -413,20 +413,20 @@
     conv2dDesc.m_BiasEnabled = true;
     IConnectableLayer* conv2d = net->AddConvolution2dLayer(conv2dDesc, weights, optionalBiases);
 
-    // Activation layer
-    armnn::ActivationDescriptor activationDesc;
-    armnn::IConnectableLayer* const activation = net->AddActivationLayer(activationDesc, "activation");
+    // Abs layer
+    armnn::ElementwiseUnaryDescriptor absDesc;
+    armnn::IConnectableLayer* const abs = net->AddElementwiseUnaryLayer(absDesc, "abs");
 
     // Output layer
     IConnectableLayer* output = net->AddOutputLayer(0, "output");
 
     input->GetOutputSlot(0).Connect(conv2d->GetInputSlot(0));
-    conv2d->GetOutputSlot(0).Connect(activation->GetInputSlot(0));
-    activation->GetOutputSlot(0).Connect(output->GetInputSlot(0));
+    conv2d->GetOutputSlot(0).Connect(abs->GetInputSlot(0));
+    abs->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     input->GetOutputSlot(0).SetTensorInfo(inputInfo);
     conv2d->GetOutputSlot(0).SetTensorInfo(outputInfo);
-    activation->GetOutputSlot(0).SetTensorInfo(outputInfo);
+    abs->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     // optimize the network
     std::vector<armnn::BackendId> backends = { backendId };
@@ -633,70 +633,70 @@
                                                offset);
     BOOST_TEST_MESSAGE("CONV2D LAYER - WORKLOAD CHILD RELATIONSHIP OK");
 
-    // Activation layer
-    // Activation layer entity
-    VerifyTimelineEntityBinaryPacketData(activation->GetGuid(), readableData, offset);
-    BOOST_TEST_MESSAGE("ACTIVATION ENTITY OK");
+    // Abs layer
+    // Abs layer entity
+    VerifyTimelineEntityBinaryPacketData(abs->GetGuid(), readableData, offset);
+    BOOST_TEST_MESSAGE("ABS ENTITY OK");
 
     // Name entity
-    ProfilingGuid activationLabelGuid = VerifyTimelineLabelBinaryPacketData(
-        EmptyOptional(), "activation", readableData, offset);
-    BOOST_TEST_MESSAGE("ACTIVATION NAME LABEL OK");
+    ProfilingGuid absLabelGuid = VerifyTimelineLabelBinaryPacketData(
+        EmptyOptional(), "abs", readableData, offset);
+    BOOST_TEST_MESSAGE("ABS NAME LABEL OK");
 
     // Entity - Name relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
                                                EmptyOptional(),
-                                               activation->GetGuid(),
-                                               activationLabelGuid,
+                                               abs->GetGuid(),
+                                               absLabelGuid,
                                                LabelsAndEventClasses::NAME_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION LAYER - NAME RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS LAYER - NAME RELATIONSHIP OK");
 
     // Entity - Type relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
                                                EmptyOptional(),
-                                               activation->GetGuid(),
+                                               abs->GetGuid(),
                                                LabelsAndEventClasses::LAYER_GUID,
                                                LabelsAndEventClasses::TYPE_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION LAYER TYPE RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS LAYER TYPE RELATIONSHIP OK");
 
-    // Network - Activation layer relationship
+    // Network - Abs layer relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
                                                EmptyOptional(),
                                                optNetGuid,
-                                               activation->GetGuid(),
+                                               abs->GetGuid(),
                                                LabelsAndEventClasses::CHILD_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("NETWORK - ACTIVATION LAYER CHILD RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("NETWORK - ABS LAYER CHILD RELATIONSHIP OK");
 
-    // Conv2d layer - Activation layer relationship
+    // Conv2d layer - Abs layer relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
                                                EmptyOptional(),
                                                conv2d->GetGuid(),
-                                               activation->GetGuid(),
+                                               abs->GetGuid(),
                                                LabelsAndEventClasses::CONNECTION_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("CONV2D LAYER - ACTIVATION LAYER CONNECTION OK");
+    BOOST_TEST_MESSAGE("CONV2D LAYER - ABS LAYER CONNECTION OK");
 
-    // Activation workload
-    // Activation workload entity
-    ProfilingGuid activationWorkloadGuid = VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD ENTITY OK");
+    // Abs workload
+    // Abs workload entity
+    ProfilingGuid absWorkloadGuid = VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
+    BOOST_TEST_MESSAGE("ABS WORKLOAD ENTITY OK");
 
     // Entity - Type relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
                                                EmptyOptional(),
-                                               activationWorkloadGuid,
+                                               absWorkloadGuid,
                                                LabelsAndEventClasses::WORKLOAD_GUID,
                                                LabelsAndEventClasses::TYPE_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLAD TYPE RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS WORKLAD TYPE RELATIONSHIP OK");
 
     // BackendId entity
     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
@@ -705,22 +705,22 @@
     // Entity - BackendId relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
                                                EmptyOptional(),
-                                               activationWorkloadGuid,
+                                               absWorkloadGuid,
                                                backendIdLabelGuid,
                                                LabelsAndEventClasses::BACKENDID_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD BACKEND ID RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD BACKEND ID RELATIONSHIP OK");
 
-    // Activation layer - Activation workload relationship
+    // Abs layer - Abs workload relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
                                                EmptyOptional(),
-                                               activation->GetGuid(),
-                                               activationWorkloadGuid,
+                                               abs->GetGuid(),
+                                               absWorkloadGuid,
                                                LabelsAndEventClasses::CHILD_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION LAYER - WORKLOAD CHILD RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS LAYER - WORKLOAD CHILD RELATIONSHIP OK");
 
     // Output layer
     // Output layer entity
@@ -761,15 +761,15 @@
                                                offset);
     BOOST_TEST_MESSAGE("NETWORK - OUTPUT LAYER CHILD RELATIONSHIP OK");
 
-    // Activation layer - Output layer relationship
+    // Abs layer - Output layer relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
                                                EmptyOptional(),
-                                               activation->GetGuid(),
+                                               abs->GetGuid(),
                                                output->GetGuid(),
                                                LabelsAndEventClasses::CONNECTION_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION LAYER - OUTPUT LAYER CONNECTION OK");
+    BOOST_TEST_MESSAGE("ABS LAYER - OUTPUT LAYER CONNECTION OK");
 
     bufferManager.MarkRead(readableBuffer);
 
@@ -1100,73 +1100,73 @@
                                                offset);
     BOOST_TEST_MESSAGE("CONV2D WORKLOAD EXECUTION END OF LIFE RELATIONSHIP OK");
 
-    // Activation workload execution
-    // Activation workload execution entity
-    ProfilingGuid activationWorkloadExecutionGuid = VerifyTimelineEntityBinaryPacketData(
+    // Abs workload execution
+    // Abs workload execution entity
+    ProfilingGuid absWorkloadExecutionGuid = VerifyTimelineEntityBinaryPacketData(
         EmptyOptional(), readableData, offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD EXECUTION ENTITY OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD EXECUTION ENTITY OK");
 
     // Entity - Type relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
                                                EmptyOptional(),
-                                               activationWorkloadExecutionGuid,
+                                               absWorkloadExecutionGuid,
                                                LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
                                                LabelsAndEventClasses::TYPE_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD EXECUTION TYPE RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD EXECUTION TYPE RELATIONSHIP OK");
 
     // Inference - Workload execution relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
                                                EmptyOptional(),
                                                inferenceGuid,
-                                               activationWorkloadExecutionGuid,
+                                               absWorkloadExecutionGuid,
                                                LabelsAndEventClasses::CHILD_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("INFERENCE - ACTIVATION WORKLOAD EXECUTION CHILD RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("INFERENCE - ABS WORKLOAD EXECUTION CHILD RELATIONSHIP OK");
 
     // Workload - Workload execution relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
                                                EmptyOptional(),
-                                               activationWorkloadGuid,
-                                               activationWorkloadExecutionGuid,
+                                               absWorkloadGuid,
+                                               absWorkloadExecutionGuid,
                                                LabelsAndEventClasses::EXECUTION_OF_GUID,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD - ACTIVATION WORKLOAD EXECUTION RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD - ABS WORKLOAD EXECUTION RELATIONSHIP OK");
 
-    // Start Activation workload execution life
+    // Start Abs workload execution life
     // Event packet - timeline, threadId, eventGuid
-    ProfilingGuid activationWorkloadExecutionSOLEventGuid = VerifyTimelineEventBinaryPacket(
+    ProfilingGuid absWorkloadExecutionSOLEventGuid = VerifyTimelineEventBinaryPacket(
         EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD EXECUTION START OF LIFE EVENT OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD EXECUTION START OF LIFE EVENT OK");
 
-    // Activation workload execution - event relationship
+    // Abs workload execution - event relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
                                                EmptyOptional(),
-                                               activationWorkloadExecutionGuid,
-                                               activationWorkloadExecutionSOLEventGuid,
+                                               absWorkloadExecutionGuid,
+                                               absWorkloadExecutionSOLEventGuid,
                                                LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD EXECUTION START OF LIFE RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD EXECUTION START OF LIFE RELATIONSHIP OK");
 
-    // End of Activation workload execution life
+    // End of Abs workload execution life
     // Event packet - timeline, threadId, eventGuid
-    ProfilingGuid activationWorkloadExecutionEOLEventGuid = VerifyTimelineEventBinaryPacket(
+    ProfilingGuid absWorkloadExecutionEOLEventGuid = VerifyTimelineEventBinaryPacket(
         EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD EXECUTION END OF LIFE EVENT OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD EXECUTION END OF LIFE EVENT OK");
 
-    // Activation workload execution - event relationship
+    // Abs workload execution - event relationship
     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
                                                EmptyOptional(),
-                                               activationWorkloadExecutionGuid,
-                                               activationWorkloadExecutionEOLEventGuid,
+                                               absWorkloadExecutionGuid,
+                                               absWorkloadExecutionEOLEventGuid,
                                                LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
                                                readableData,
                                                offset);
-    BOOST_TEST_MESSAGE("ACTIVATION WORKLOAD EXECUTION END OF LIFE RELATIONSHIP OK");
+    BOOST_TEST_MESSAGE("ABS WORKLOAD EXECUTION END OF LIFE RELATIONSHIP OK");
 
     // Output workload execution
     // Output workload execution entity