From 611c7fb97412230d5cefee047081455fb60db06c Mon Sep 17 00:00:00 2001
From: Teresa Charlin <teresa.charlinreyes@arm.com>
Date: Fri, 7 Jan 2022 09:47:29 +0000
Subject: IVGCVSW-6641 Stabilize the IWorkloadFactory interface with unified
 strategy

Signed-off-by: Teresa Charlin <teresa.charlinreyes@arm.com>
Change-Id: Ia941be9bf2c15fe56e49a9b9a2bbe943a8152438
---
 src/backends/neon/NeonWorkloadFactory.cpp | 429 ++++++++++++++++++++++++++++++
 src/backends/neon/NeonWorkloadFactory.hpp | 132 ++++++++-
 src/backends/neon/test/NeonTimerTest.cpp  |   3 +-
 3 files changed, 562 insertions(+), 2 deletions(-)

(limited to 'src/backends/neon')

diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index 2d0b8907f7..19d322b75d 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -131,6 +131,435 @@ std::unique_ptr<ITensorHandle> NeonWorkloadFactory::CreateTensorHandle(const Ten
     return tensorHandle;
 }
 
+std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateWorkload(LayerType type,
+                                                               const QueueDescriptor& descriptor,
+                                                               const WorkloadInfo& info) const
+{
+    switch(type)
+    {
+        case LayerType::Activation :
+        {
+            auto activationQueueDescriptor = PolymorphicDowncast<const ActivationQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonActivationWorkload>(*activationQueueDescriptor, info);
+        }
+        case LayerType::Addition :
+        {
+            auto additionQueueDescriptor = PolymorphicDowncast<const AdditionQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonAdditionWorkload>(*additionQueueDescriptor, info);
+        }
+        case LayerType::ArgMinMax :
+        {
+            auto argMinMaxQueueDescriptor = PolymorphicDowncast<const ArgMinMaxQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonArgMinMaxWorkload>(*argMinMaxQueueDescriptor, info);
+        }
+        case LayerType::BatchNormalization :
+        {
+            auto batchNormalizationQueueDescriptor
+                    = PolymorphicDowncast<const BatchNormalizationQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonBatchNormalizationWorkload>(*batchNormalizationQueueDescriptor, info);
+        }
+        case LayerType::BatchToSpaceNd :
+        {
+            auto batchToSpaceNdQueueDescriptor
+                    = PolymorphicDowncast<const BatchToSpaceNdQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonBatchToSpaceNdWorkload>(*batchToSpaceNdQueueDescriptor, info);
+        }
+        case LayerType::Cast :
+        {
+            auto castQueueDescriptor = PolymorphicDowncast<const CastQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonCastWorkload>(*castQueueDescriptor, info);
+        }
+        case LayerType::ChannelShuffle :
+        {
+            auto channelShuffleQueueDescriptor = PolymorphicDowncast<const ChannelShuffleQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonChannelShuffleWorkload>(*channelShuffleQueueDescriptor, info);
+        }
+        case LayerType::Comparison :
+        {
+            auto comparisonQueueDescriptor = PolymorphicDowncast<const ComparisonQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonComparisonWorkload>(*comparisonQueueDescriptor, info);
+        }
+        case LayerType::Concat :
+        {
+            auto concatQueueDescriptor = PolymorphicDowncast<const ConcatQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonConcatWorkload>(*concatQueueDescriptor, info);
+        }
+        case LayerType::Constant :
+        {
+            auto constantQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonConstantWorkload>(*constantQueueDescriptor, info);
+        }
+        case LayerType::ConvertBf16ToFp32 :
+        {
+            auto convertBf16ToFp32QueueDescriptor
+                    = PolymorphicDowncast<const ConvertBf16ToFp32QueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonConvertBf16ToFp32Workload>(*convertBf16ToFp32QueueDescriptor, info);
+        }
+        case LayerType::ConvertFp16ToFp32 :
+        {
+            auto convertFp16ToFp32QueueDescriptor
+                    = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonConvertFp16ToFp32Workload>(*convertFp16ToFp32QueueDescriptor, info);
+        }
+        case LayerType::ConvertFp32ToBf16 :
+        {
+            auto convertFp32ToBf16QueueDescriptor
+                    = PolymorphicDowncast<const ConvertFp32ToBf16QueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonConvertFp32ToBf16Workload>(*convertFp32ToBf16QueueDescriptor, info);
+        }
+        case LayerType::ConvertFp32ToFp16 :
+        {
+            auto convertFp32ToFp16QueueDescriptor
+                    = PolymorphicDowncast<const ConvertFp32ToFp16QueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonConvertFp32ToFp16Workload>(*convertFp32ToFp16QueueDescriptor, info);
+        }
+        case LayerType::Convolution2d :
+        {
+            auto convolution2dQueueDescriptor = PolymorphicDowncast<const Convolution2dQueueDescriptor*>(&descriptor);
+
+            bool isFastMathEnabled = false;
+            if (m_ModelContextPtr)
+            {
+                if (m_ModelContextPtr.get() != nullptr)
+                {
+                    auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
+                    if (modelOptions)
+                    {
+                        isFastMathEnabled = modelOptions->IsFastMathEnabled();
+                    }
+                }
+            }
+            return std::make_unique<NeonConvolution2dWorkload>(*convolution2dQueueDescriptor,
+                                                               info,
+                                                               m_MemoryManager->GetIntraLayerManager(),
+                                                               isFastMathEnabled);
+        }
+        case LayerType::Convolution3d :
+        {
+            auto convolution3dQueueDescriptor = PolymorphicDowncast<const Convolution3dQueueDescriptor*>(&descriptor);
+
+            bool isFastMathEnabled = false;
+            if (m_ModelContextPtr)
+            {
+                if (m_ModelContextPtr.get() != nullptr)
+                {
+                    auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
+                    if (modelOptions)
+                    {
+                        isFastMathEnabled = modelOptions->IsFastMathEnabled();
+                    }
+                }
+            }
+            return std::make_unique<NeonConvolution3dWorkload>(*convolution3dQueueDescriptor,
+                                                               info,
+                                                               m_MemoryManager->GetIntraLayerManager(),
+                                                               isFastMathEnabled);
+        }
+        case LayerType::Debug :
+        {
+            auto debugQueueDescriptor = PolymorphicDowncast<const DebugQueueDescriptor*>(&descriptor);
+            return MakeWorkloadHelper<NullWorkload, NullWorkload>(*debugQueueDescriptor, info);
+        }
+        case LayerType::DepthToSpace :
+        {
+            auto depthToSpaceQueueDescriptor = PolymorphicDowncast<const DepthToSpaceQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonDepthToSpaceWorkload>(*depthToSpaceQueueDescriptor, info);
+        }
+        case LayerType::DepthwiseConvolution2d :
+        {
+            auto depthwiseConvolution2dQueueDescriptor
+                    = PolymorphicDowncast<const DepthwiseConvolution2dQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonDepthwiseConvolutionWorkload>(*depthwiseConvolution2dQueueDescriptor, info);
+        }
+        case LayerType::Dequantize :
+        {
+            auto dequantizeQueueDescriptor = PolymorphicDowncast<const DequantizeQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonDequantizeWorkload>(*dequantizeQueueDescriptor, info);
+        }
+        case LayerType::DetectionPostProcess :
+        {
+            auto detectionPostProcessQueueDescriptor
+                    = PolymorphicDowncast<const DetectionPostProcessQueueDescriptor*>(&descriptor);
+            return MakeWorkloadHelper<NullWorkload, NullWorkload>(*detectionPostProcessQueueDescriptor, info);
+        }
+        case LayerType::Division :
+        {
+            auto divisionQueueDescriptor = PolymorphicDowncast<const DivisionQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonDivisionWorkload>(*divisionQueueDescriptor, info);
+        }
+        case LayerType::ElementwiseUnary :
+        {
+            auto elementwiseUnaryQueueDescriptor
+                    = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
+
+            switch(elementwiseUnaryQueueDescriptor->m_Parameters.m_Operation)
+            {
+                case UnaryOperation::Abs:
+                {
+                    AbsQueueDescriptor absQueueDescriptor;
+                    absQueueDescriptor.m_Inputs  = elementwiseUnaryQueueDescriptor->m_Inputs;
+                    absQueueDescriptor.m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
+
+                    return std::make_unique<NeonAbsWorkload>(absQueueDescriptor, info);
+                }
+                case UnaryOperation::Exp:
+                    return std::make_unique<NeonExpWorkload>(*elementwiseUnaryQueueDescriptor, info);
+                case UnaryOperation::LogicalNot:
+                    return std::make_unique<NeonLogicalNotWorkload>(*elementwiseUnaryQueueDescriptor, info);
+                case UnaryOperation::Log:
+                    return std::make_unique<NeonLogWorkload>(*elementwiseUnaryQueueDescriptor, info);
+                case UnaryOperation::Neg:
+                    return std::make_unique<NeonNegWorkload>(*elementwiseUnaryQueueDescriptor, info);
+                case UnaryOperation::Rsqrt:
+                {
+                    RsqrtQueueDescriptor rsqrtQueueDescriptor;
+                    rsqrtQueueDescriptor.m_Inputs  = elementwiseUnaryQueueDescriptor->m_Inputs;
+                    rsqrtQueueDescriptor.m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
+
+                    return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor, info);
+                }
+                case UnaryOperation::Sin:
+                    return std::make_unique<NeonSinWorkload>(*elementwiseUnaryQueueDescriptor, info);
+                default:
+                    return nullptr;
+            }
+        }
+        case LayerType::Fill :
+        {
+            auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonFillWorkload>(*fillQueueDescriptor, info);
+        }
+        case LayerType::Floor :
+        {
+            auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
+            return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(*floorQueueDescriptor, info);
+        }
+        case LayerType::FullyConnected :
+        {
+            auto fullyConnectedQueueDescriptor = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonFullyConnectedWorkload>(*fullyConnectedQueueDescriptor,
+                                                                info,
+                                                                m_MemoryManager->GetIntraLayerManager());
+        }
+        case LayerType::Gather :
+        {
+            auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonGatherWorkload>(*gatherQueueDescriptor, info);
+        }
+        case LayerType::Input :
+        {
+            auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
+            return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor, info);
+        }
+        case LayerType::InstanceNormalization :
+        {
+            auto instanceNormalizationQueueDescriptor
+                    = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonInstanceNormalizationWorkload>(*instanceNormalizationQueueDescriptor, info);
+        }
+        case LayerType::L2Normalization :
+        {
+            auto l2NormalizationQueueDescriptor
+                    = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
+            return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>
+                    (*l2NormalizationQueueDescriptor, info, m_MemoryManager->GetIntraLayerManager());
+        }
+        case LayerType::LogSoftmax :
+        {
+            auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonLogSoftmaxWorkload>(*logSoftmaxQueueDescriptor,
+                                                            info,
+                                                            m_MemoryManager->GetIntraLayerManager());
+        }
+        case LayerType::LogicalBinary :
+        {
+            auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
+
+            switch(logicalBinaryQueueDescriptor->m_Parameters.m_Operation)
+            {
+                case LogicalBinaryOperation::LogicalAnd:
+                    return std::make_unique<NeonLogicalAndWorkload>(*logicalBinaryQueueDescriptor, info);
+                case LogicalBinaryOperation::LogicalOr:
+                    return std::make_unique<NeonLogicalOrWorkload>(*logicalBinaryQueueDescriptor, info);
+                default:
+                    return nullptr;
+            }
+        }
+        case LayerType::Lstm :
+        {
+            auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
+            return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(*lstmQueueDescriptor, info);
+        }
+        case LayerType::Maximum :
+        {
+            auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonMaximumWorkload>(*maximumQueueDescriptor, info);
+        }
+        case LayerType::Mean :
+        {
+            auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonMeanWorkload>(*meanQueueDescriptor, info);
+        }
+        case LayerType::MemCopy :
+        {
+            auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
+            if (memCopyQueueDescriptor->m_Inputs.empty() || !memCopyQueueDescriptor->m_Inputs[0])
+            {
+                throw InvalidArgumentException("NeonWorkloadFactory: Invalid null input for MemCopy workload");
+            }
+            return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(*memCopyQueueDescriptor, info);
+        }
+        case LayerType::MemImport :
+        {
+            auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
+            if (memImportQueueDescriptor->m_Inputs.empty() || !memImportQueueDescriptor->m_Inputs[0])
+            {
+                throw InvalidArgumentException("NeonWorkloadFactory: Invalid null input for MemImport workload");
+            }
+            return std::make_unique<ImportMemGenericWorkload>(*memImportQueueDescriptor, info);
+        }
+        case LayerType::Minimum :
+        {
+            auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonMinimumWorkload>(*minimumQueueDescriptor, info);
+        }
+        case LayerType::Multiplication :
+        {
+            auto multiplicationQueueDescriptor = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonMultiplicationWorkload>(*multiplicationQueueDescriptor, info);
+        }
+        case LayerType::Normalization :
+        {
+            auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
+            return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>
+                    (*normalizationQueueDescriptor, info, m_MemoryManager->GetIntraLayerManager());
+        }
+        case LayerType::Output :
+        {
+            auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
+            return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor, info);
+        }
+        case LayerType::Pad :
+        {
+            auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonPadWorkload>(*padQueueDescriptor, info);
+        }
+        case LayerType::Permute :
+        {
+            auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonPermuteWorkload>(*permuteQueueDescriptor, info);
+        }
+        case LayerType::Pooling2d :
+        {
+            auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonPooling2dWorkload>(*pooling2dQueueDescriptor, info);
+        }
+        case LayerType::PreCompiled :
+        {
+            auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
+            return MakeWorkloadHelper<NullWorkload, NullWorkload>(*preCompiledQueueDescriptor, info);
+        }
+        case LayerType::Prelu :
+        {
+            auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonPreluWorkload>(*preluQueueDescriptor, info);
+        }
+        case LayerType::QLstm :
+        {
+            auto qLstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonQLstmWorkload>(*qLstmQueueDescriptor, info);
+        }
+        case LayerType::Quantize :
+        {
+            auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonQuantizeWorkload>(*quantizeQueueDescriptor, info);
+        }
+        case LayerType::QuantizedLstm :
+        {
+            auto quantizedLstmQueueDescriptor = PolymorphicDowncast<const QuantizedLstmQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonQuantizedLstmWorkload>(*quantizedLstmQueueDescriptor, info);
+        }
+        case LayerType::Rank :
+        {
+            auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonRankWorkload>(*rankQueueDescriptor, info);
+        }
+        case LayerType::Reduce :
+        {
+            auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonReduceWorkload>(*reduceQueueDescriptor, info);
+        }
+        case LayerType::Reshape :
+        {
+            auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonReshapeWorkload>(*reshapeQueueDescriptor, info);
+        }
+        case LayerType::Resize :
+        {
+            auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonResizeWorkload>(*resizeQueueDescriptor, info);
+        }
+        case LayerType::Slice :
+        {
+            auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonSliceWorkload>(*sliceQueueDescriptor, info);
+        }
+        case LayerType::Softmax :
+        {
+            auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonSoftmaxWorkload>(*softmaxQueueDescriptor,
+                                                         info,
+                                                         m_MemoryManager->GetIntraLayerManager());
+        }
+        case LayerType::SpaceToBatchNd :
+        {
+            auto spaceToBatchNdQueueDescriptor
+                    = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonSpaceToBatchNdWorkload>(*spaceToBatchNdQueueDescriptor, info);
+        }
+        case LayerType::SpaceToDepth :
+        {
+            auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonSpaceToDepthWorkload>(*spaceToDepthQueueDescriptor, info);
+        }
+        case LayerType::Splitter :
+        {
+            auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonSplitterWorkload>(*splitterQueueDescriptor, info);
+        }
+        case LayerType::Stack :
+        {
+            auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonStackWorkload>(*stackQueueDescriptor, info);
+        }
+        case LayerType::StridedSlice :
+        {
+            auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonStridedSliceWorkload>(*stridedSliceQueueDescriptor, info);
+        }
+        case LayerType::Subtraction :
+        {
+            auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonSubtractionWorkload>(*subtractionQueueDescriptor, info);
+        }
+        case LayerType::Transpose :
+        {
+            auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonTransposeWorkload>(*transposeQueueDescriptor, info);
+        }
+        case LayerType::TransposeConvolution2d :
+        {
+            auto transposeConvolution2dQueueDescriptor
+                    = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonTransposeConvolution2dWorkload>(*transposeConvolution2dQueueDescriptor,
+                                                                        info,
+                                                                        m_MemoryManager->GetIntraLayerManager());
+        }
+        default:
+            return nullptr;
+    }
+}
+
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateActivation(const ActivationQueueDescriptor& descriptor,
                                                                  const WorkloadInfo&              info) const
 {
diff --git a/src/backends/neon/NeonWorkloadFactory.hpp b/src/backends/neon/NeonWorkloadFactory.hpp
index f44681a5a8..802b9e1ac9 100644
--- a/src/backends/neon/NeonWorkloadFactory.hpp
+++ b/src/backends/neon/NeonWorkloadFactory.hpp
@@ -52,192 +52,322 @@ public:
                                                       DataLayout dataLayout,
                                                       const bool IsMemoryManaged = true) const override;
 
+    std::unique_ptr<IWorkload> CreateWorkload(LayerType type,
+                                              const QueueDescriptor& descriptor,
+                                              const WorkloadInfo& info) const override;
+
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateActivation(const ActivationQueueDescriptor& descriptor,
                                                 const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateAddition(const AdditionQueueDescriptor& descriptor,
                                               const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateArgMinMax(const ArgMinMaxQueueDescriptor& descriptor,
                                                const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateBatchNormalization(const BatchNormalizationQueueDescriptor& descriptor,
                                                         const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
                                                     const WorkloadInfo& Info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateCast(const CastQueueDescriptor& descriptor,
                                           const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateChannelShuffle(const ChannelShuffleQueueDescriptor& descriptor,
                                                     const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateComparison(const ComparisonQueueDescriptor& descriptor,
                                                 const WorkloadInfo& Info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConcat(const ConcatQueueDescriptor& descriptor,
                                             const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConstant(const ConstantQueueDescriptor& descriptor,
                                               const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConvertBf16ToFp32(const ConvertBf16ToFp32QueueDescriptor& descriptor,
                                                        const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConvertFp16ToFp32(const ConvertFp16ToFp32QueueDescriptor& descriptor,
                                                        const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConvertFp32ToBf16(const ConvertFp32ToBf16QueueDescriptor& descriptor,
                                                        const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConvertFp32ToFp16(const ConvertFp32ToFp16QueueDescriptor& descriptor,
                                                        const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateConvolution3d(const Convolution3dQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateDebug(const DebugQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateDepthToSpace(const DepthToSpaceQueueDescriptor& descriptor,
                                                   const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateDepthwiseConvolution2d(const DepthwiseConvolution2dQueueDescriptor& descriptor,
                                                             const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateDequantize(const DequantizeQueueDescriptor& descriptor,
                                                 const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateDetectionPostProcess(const DetectionPostProcessQueueDescriptor& descriptor,
                                                           const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateDivision(const DivisionQueueDescriptor& descriptor,
                                               const WorkloadInfo& info) const override;
-    
+
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateElementwiseUnary(const ElementwiseUnaryQueueDescriptor& descriptor,
                                                       const WorkloadInfo& Info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateFill(const FillQueueDescriptor& descriptor,
                                           const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateFloor(const FloorQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateFullyConnected(const FullyConnectedQueueDescriptor& descriptor,
                                                     const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateGather(const GatherQueueDescriptor& descriptor,
                                             const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateInput(const InputQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateInstanceNormalization(const InstanceNormalizationQueueDescriptor& descriptor,
                                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor,
                                                      const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateLogicalBinary(const LogicalBinaryQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateLogSoftmax(const LogSoftmaxQueueDescriptor& descriptor,
                                                 const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateLstm(const LstmQueueDescriptor& descriptor,
                                           const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateMaximum(const MaximumQueueDescriptor& descriptor,
                                              const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateMean(const MeanQueueDescriptor& descriptor,
                                           const WorkloadInfo& Info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateMemCopy(const MemCopyQueueDescriptor& descriptor,
                                              const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateMemImport(const MemImportQueueDescriptor& descriptor,
                                                const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateMinimum(const MinimumQueueDescriptor& descriptor,
                                              const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateMultiplication(const MultiplicationQueueDescriptor& descriptor,
                                                     const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateNormalization(const NormalizationQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateOutput(const OutputQueueDescriptor& descriptor,
                                             const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreatePad(const PadQueueDescriptor& descriptor,
                                          const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreatePermute(const PermuteQueueDescriptor& descriptor,
                                              const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreatePooling2d(const Pooling2dQueueDescriptor& descriptor,
                                                const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreatePreCompiled(const PreCompiledQueueDescriptor& descriptor,
                                                  const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreatePrelu(const PreluQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateQLstm(const QLstmQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateQuantize(const QuantizeQueueDescriptor& descriptor,
                                               const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateQuantizedLstm(const QuantizedLstmQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateRank(const RankQueueDescriptor& descriptor,
                                           const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateReduce(const ReduceQueueDescriptor& descriptor,
                                             const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateReshape(const ReshapeQueueDescriptor& descriptor,
                                              const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateResize(const ResizeQueueDescriptor& descriptor,
                                             const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateSlice(const SliceQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
                                              const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
                                                     const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateSpaceToDepth(const SpaceToDepthQueueDescriptor& descriptor,
                                                   const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateSplitter(const SplitterQueueDescriptor& descriptor,
                                               const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateStack(const StackQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateStridedSlice(const StridedSliceQueueDescriptor& descriptor,
                                                   const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateSubtraction(const SubtractionQueueDescriptor& descriptor,
                                                  const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateTranspose(const TransposeQueueDescriptor& descriptor,
                                                const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+    "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "22.08")
     std::unique_ptr<IWorkload> CreateTransposeConvolution2d(const TransposeConvolution2dQueueDescriptor& descriptor,
                                                             const WorkloadInfo& info) const override;
 
diff --git a/src/backends/neon/test/NeonTimerTest.cpp b/src/backends/neon/test/NeonTimerTest.cpp
index 6f96df54cd..7d73df83bd 100644
--- a/src/backends/neon/test/NeonTimerTest.cpp
+++ b/src/backends/neon/test/NeonTimerTest.cpp
@@ -78,7 +78,8 @@ TEST_CASE("NeonTimerMeasure")
     descriptor.m_Parameters.m_A = upperBound;
     descriptor.m_Parameters.m_B = lowerBound;
 
-    std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateActivation(descriptor, workloadInfo);
+    std::unique_ptr<armnn::IWorkload> workload
+            = workloadFactory.CreateWorkload(LayerType::Activation, descriptor, workloadInfo);
 
     inputHandle->Allocate();
     outputHandle->Allocate();
-- 
cgit v1.2.1