From d80a7126b0abdd532a9f731559827a23f2e565e0 Mon Sep 17 00:00:00 2001 From: Matthew Bentham Date: Tue, 8 Jan 2019 17:52:37 +0000 Subject: Refactor: Don't include all ComputeLibrary function definitions everywhere. Just include the function definition that is specifically needed for each workload. Also, tighten up the scope where Compute Library functions are available. Knocks about 30seconds off a 4m30s single-threaded compile of the Neon workloads. Change-Id: Idac438f3bc77ff978295fbc9505cb42447def145 --- .../neon/workloads/NeonActivationWorkload.cpp | 10 +++++++-- .../neon/workloads/NeonActivationWorkload.hpp | 7 ++++-- .../neon/workloads/NeonAdditionWorkload.cpp | 10 +++++++-- .../neon/workloads/NeonAdditionWorkload.hpp | 7 ++++-- .../workloads/NeonBatchNormalizationWorkload.cpp | 26 +++++++++++++--------- .../workloads/NeonBatchNormalizationWorkload.hpp | 9 ++++++-- .../neon/workloads/NeonConvolution2dWorkload.cpp | 4 +++- .../neon/workloads/NeonConvolution2dWorkload.hpp | 6 ++--- .../workloads/NeonDepthwiseConvolutionWorkload.cpp | 7 ++++++ .../workloads/NeonDepthwiseConvolutionWorkload.hpp | 7 +++++- .../neon/workloads/NeonFloorFloatWorkload.cpp | 12 ++++++++-- .../neon/workloads/NeonFloorFloatWorkload.hpp | 9 ++++++-- .../neon/workloads/NeonFullyConnectedWorkload.cpp | 13 +++++++---- .../neon/workloads/NeonFullyConnectedWorkload.hpp | 7 ++++-- .../workloads/NeonL2NormalizationFloatWorkload.cpp | 12 +++++++--- .../workloads/NeonL2NormalizationFloatWorkload.hpp | 7 ++++-- src/backends/neon/workloads/NeonMergerWorkload.cpp | 13 +++++++---- src/backends/neon/workloads/NeonMergerWorkload.hpp | 8 +++++-- .../workloads/NeonMultiplicationFloatWorkload.cpp | 19 ++++++++++------ .../workloads/NeonMultiplicationFloatWorkload.hpp | 9 ++++++-- .../workloads/NeonNormalizationFloatWorkload.cpp | 13 ++++++----- .../workloads/NeonNormalizationFloatWorkload.hpp | 9 ++++++-- .../neon/workloads/NeonPooling2dWorkload.cpp | 12 +++++++--- .../neon/workloads/NeonPooling2dWorkload.hpp | 9 ++++++-- .../neon/workloads/NeonReshapeWorkload.cpp | 12 ++++++++-- .../neon/workloads/NeonReshapeWorkload.hpp | 8 +++++-- .../neon/workloads/NeonSoftmaxBaseWorkload.cpp | 2 ++ .../neon/workloads/NeonSoftmaxBaseWorkload.hpp | 3 ++- .../neon/workloads/NeonSoftmaxFloatWorkload.cpp | 11 ++++++--- .../neon/workloads/NeonSoftmaxFloatWorkload.hpp | 6 +++-- .../neon/workloads/NeonSoftmaxUint8Workload.cpp | 11 ++++++--- .../neon/workloads/NeonSoftmaxUint8Workload.hpp | 8 +++++-- .../workloads/NeonSubtractionFloatWorkload.cpp | 10 +++++++-- .../workloads/NeonSubtractionFloatWorkload.hpp | 9 ++++++-- src/backends/neon/workloads/NeonWorkloadUtils.hpp | 1 - 35 files changed, 238 insertions(+), 88 deletions(-) (limited to 'src') diff --git a/src/backends/neon/workloads/NeonActivationWorkload.cpp b/src/backends/neon/workloads/NeonActivationWorkload.cpp index 6e95678d13..c75a138301 100644 --- a/src/backends/neon/workloads/NeonActivationWorkload.cpp +++ b/src/backends/neon/workloads/NeonActivationWorkload.cpp @@ -4,8 +4,11 @@ // #include "NeonActivationWorkload.hpp" +#include "NeonWorkloadUtils.hpp" #include +#include + namespace armnn { @@ -43,13 +46,16 @@ NeonActivationWorkload::NeonActivationWorkload(const ActivationQueueDescriptor& arm_compute::ITensor& input = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); arm_compute::ITensor& output = boost::polymorphic_downcast(m_Data.m_Outputs[0])->GetTensor(); - m_ActivationLayer.configure(&input, &output, activationLayerInfo); + auto layer = std::make_unique(); + layer->configure(&input, &output, activationLayerInfo); + + m_ActivationLayer.reset(layer.release()); } void NeonActivationWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonActivationWorkload_Execute"); - m_ActivationLayer.run(); + m_ActivationLayer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonActivationWorkload.hpp b/src/backends/neon/workloads/NeonActivationWorkload.hpp index fc7c6467dc..eefbfb6522 100644 --- a/src/backends/neon/workloads/NeonActivationWorkload.hpp +++ b/src/backends/neon/workloads/NeonActivationWorkload.hpp @@ -5,7 +5,10 @@ #pragma once -#include +#include + +#include +#include namespace armnn { @@ -21,7 +24,7 @@ public: void Execute() const override; private: - mutable arm_compute::NEActivationLayer m_ActivationLayer; + std::unique_ptr m_ActivationLayer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonAdditionWorkload.cpp b/src/backends/neon/workloads/NeonAdditionWorkload.cpp index 70a3909091..fa537819a9 100644 --- a/src/backends/neon/workloads/NeonAdditionWorkload.cpp +++ b/src/backends/neon/workloads/NeonAdditionWorkload.cpp @@ -4,9 +4,13 @@ // #include "NeonAdditionWorkload.hpp" +#include "NeonWorkloadUtils.hpp" + #include #include +#include + namespace armnn { @@ -35,13 +39,15 @@ NeonAdditionWorkload::NeonAdditionWorkload(const AdditionQueueDescriptor& descri arm_compute::ITensor& input2 = boost::polymorphic_downcast(m_Data.m_Inputs[1])->GetTensor(); arm_compute::ITensor& output = boost::polymorphic_downcast(m_Data.m_Outputs[0])->GetTensor(); - m_AddLayer.configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE); + auto layer = std::make_unique(); + layer->configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE); + m_AddLayer.reset(layer.release()); } void NeonAdditionWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonAdditionWorkload_Execute"); - m_AddLayer.run(); + m_AddLayer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonAdditionWorkload.hpp b/src/backends/neon/workloads/NeonAdditionWorkload.hpp index ca8ae8d7b7..826fb1f3dd 100644 --- a/src/backends/neon/workloads/NeonAdditionWorkload.hpp +++ b/src/backends/neon/workloads/NeonAdditionWorkload.hpp @@ -5,7 +5,10 @@ #pragma once -#include +#include + +#include +#include namespace armnn { @@ -21,7 +24,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEArithmeticAddition m_AddLayer; + std::unique_ptr m_AddLayer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp index 44d5035431..fc80f413e8 100644 --- a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp +++ b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp @@ -4,9 +4,13 @@ // #include "NeonBatchNormalizationWorkload.hpp" + +#include "NeonWorkloadUtils.hpp" + #include #include -#include + +#include namespace armnn { @@ -68,13 +72,15 @@ NeonBatchNormalizationWorkload::NeonBatchNormalizationWorkload( m_Beta = std::make_unique(); BuildArmComputeTensor(*m_Beta, m_Data.m_Beta->GetTensorInfo()); - m_Layer.configure(&input, - &output, - m_Mean.get(), - m_Variance.get(), - m_Beta.get(), - m_Gamma.get(), - m_Data.m_Parameters.m_Eps); + auto layer = std::make_unique(); + layer->configure(&input, + &output, + m_Mean.get(), + m_Variance.get(), + m_Beta.get(), + m_Gamma.get(), + m_Data.m_Parameters.m_Eps); + m_Layer.reset(layer.release()); InitializeArmComputeTensorData(*m_Mean, m_Data.m_Mean); InitializeArmComputeTensorData(*m_Variance, m_Data.m_Variance); @@ -83,14 +89,14 @@ NeonBatchNormalizationWorkload::NeonBatchNormalizationWorkload( // Force Compute Library to perform the necessary copying and reshaping, after which // delete all the input tensors that will no longer be needed - m_Layer.prepare(); + m_Layer->prepare(); FreeUnusedTensors(); } void NeonBatchNormalizationWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonBatchNormalizationWorkload_Execute"); - m_Layer.run(); + m_Layer->run(); } void NeonBatchNormalizationWorkload::FreeUnusedTensors() diff --git a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp index 52e4db7c90..3619ea0d73 100644 --- a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp +++ b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.hpp @@ -5,7 +5,12 @@ #pragma once -#include +#include + +#include +#include + +#include namespace armnn { @@ -26,7 +31,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEBatchNormalizationLayer m_Layer; + std::unique_ptr m_Layer; std::unique_ptr m_Mean; std::unique_ptr m_Variance; diff --git a/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp index 151132f04d..1080f320e7 100644 --- a/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp +++ b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp @@ -7,7 +7,9 @@ #include #include -#include +#include + +#include #include #include diff --git a/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp b/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp index daf9a43fe4..3fb408dbaa 100644 --- a/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp +++ b/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp @@ -5,12 +5,10 @@ #pragma once -#include -#include -#include -#include #include +#include +#include #include #include diff --git a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp index be26359662..c915555dd7 100644 --- a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp +++ b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp @@ -5,11 +5,18 @@ #include "NeonDepthwiseConvolutionWorkload.hpp" +#include "NeonWorkloadUtils.hpp" + +#include #include #include #include #include +#include + +using namespace armnnUtils; + namespace armnn { diff --git a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp index b5f2ae9223..85932d3f9a 100644 --- a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp +++ b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.hpp @@ -5,7 +5,12 @@ #pragma once -#include +#include + +#include +#include + +#include namespace armnn { diff --git a/src/backends/neon/workloads/NeonFloorFloatWorkload.cpp b/src/backends/neon/workloads/NeonFloorFloatWorkload.cpp index a08ba8a6ec..f024fef2a8 100644 --- a/src/backends/neon/workloads/NeonFloorFloatWorkload.cpp +++ b/src/backends/neon/workloads/NeonFloorFloatWorkload.cpp @@ -5,6 +5,12 @@ #include "NeonFloorFloatWorkload.hpp" +#include "NeonWorkloadUtils.hpp" + +#include + +#include + namespace armnn { NeonFloorFloatWorkload::NeonFloorFloatWorkload(const FloorQueueDescriptor& descriptor, @@ -16,13 +22,15 @@ NeonFloorFloatWorkload::NeonFloorFloatWorkload(const FloorQueueDescriptor& descr arm_compute::ITensor& input = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); arm_compute::ITensor& output = boost::polymorphic_downcast(m_Data.m_Outputs[0])->GetTensor(); - m_Layer.configure(&input, &output); + auto layer = std::make_unique(); + layer->configure(&input, &output); + m_Layer.reset(layer.release()); } void NeonFloorFloatWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFloorFloatWorkload_Execute"); - m_Layer.run(); + m_Layer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonFloorFloatWorkload.hpp b/src/backends/neon/workloads/NeonFloorFloatWorkload.hpp index a4ce47663c..01b86a6706 100644 --- a/src/backends/neon/workloads/NeonFloorFloatWorkload.hpp +++ b/src/backends/neon/workloads/NeonFloorFloatWorkload.hpp @@ -5,7 +5,12 @@ #pragma once -#include +#include + +#include +#include + +#include namespace armnn { @@ -17,7 +22,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEFloor m_Layer; + std::unique_ptr m_Layer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp b/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp index e432a6b833..7395270400 100644 --- a/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp +++ b/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp @@ -5,10 +5,13 @@ #include "NeonFullyConnectedWorkload.hpp" +#include "NeonWorkloadUtils.hpp" #include #include #include +#include + namespace armnn { using namespace armcomputetensorutils; @@ -45,7 +48,6 @@ arm_compute::Status NeonFullyConnectedWorkloadValidate(const TensorInfo& input, NeonFullyConnectedWorkload::NeonFullyConnectedWorkload(const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info, std::shared_ptr& memoryManager) : BaseWorkload(descriptor, info) - , m_FullyConnectedLayer(memoryManager) { m_Data.ValidateInputsOutputs("NeonFullyConnectedWorkload", 1, 1); @@ -64,7 +66,10 @@ NeonFullyConnectedWorkload::NeonFullyConnectedWorkload(const FullyConnectedQueue // Construct arm_compute::FullyConnectedLayerInfo fc_info; fc_info.transpose_weights = m_Data.m_Parameters.m_TransposeWeightMatrix; - m_FullyConnectedLayer.configure(&input, m_WeightsTensor.get(), m_BiasesTensor.get(), &output, fc_info); + + auto layer = std::make_unique(memoryManager); + layer->configure(&input, m_WeightsTensor.get(), m_BiasesTensor.get(), &output, fc_info); + m_FullyConnectedLayer.reset(layer.release()); // Allocate if (m_Data.m_Weight->GetTensorInfo().GetDataType() == DataType::QuantisedAsymm8) @@ -90,14 +95,14 @@ NeonFullyConnectedWorkload::NeonFullyConnectedWorkload(const FullyConnectedQueue // Force Compute Library to perform the necessary copying and reshaping, after which // delete all the input tensors that will no longer be needed - m_FullyConnectedLayer.prepare(); + m_FullyConnectedLayer->prepare(); FreeUnusedTensors(); } void NeonFullyConnectedWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFullyConnectedWorkload_Execute"); - m_FullyConnectedLayer.run(); + m_FullyConnectedLayer->run(); } void NeonFullyConnectedWorkload::FreeUnusedTensors() diff --git a/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp b/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp index ec1661d642..1cd8be109a 100644 --- a/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp +++ b/src/backends/neon/workloads/NeonFullyConnectedWorkload.hpp @@ -5,9 +5,12 @@ #pragma once -#include +#include +#include +#include #include +#include #include @@ -28,7 +31,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEFullyConnectedLayer m_FullyConnectedLayer; + std::unique_ptr m_FullyConnectedLayer; std::unique_ptr m_WeightsTensor; std::unique_ptr m_BiasesTensor; diff --git a/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.cpp b/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.cpp index afaa700624..99bbcfa824 100644 --- a/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.cpp +++ b/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.cpp @@ -4,8 +4,13 @@ // #include "NeonL2NormalizationFloatWorkload.hpp" + +#include "NeonWorkloadUtils.hpp" + #include +#include + namespace armnn { using namespace armcomputetensorutils; @@ -25,7 +30,6 @@ arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo& input, NeonL2NormalizationFloatWorkload::NeonL2NormalizationFloatWorkload(const L2NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info, std::shared_ptr& memoryManager) : FloatWorkload(descriptor, info) - , m_Layer(memoryManager) { m_Data.ValidateInputsOutputs("NeonL2NormalizationFloatWorkload", 1, 1); @@ -38,13 +42,15 @@ NeonL2NormalizationFloatWorkload::NeonL2NormalizationFloatWorkload(const L2Norma unsigned int axis = (m_Data.m_Parameters.m_DataLayout == DataLayout::NCHW) ? 2 : 0; - m_Layer.configure(&input, &output, axis); + auto layer = std::make_unique(memoryManager); + layer->configure(&input, &output, axis); + m_Layer.reset(layer.release()); } void NeonL2NormalizationFloatWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonL2NormalizationFloatWorkload_Execute"); - m_Layer.run(); + m_Layer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.hpp b/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.hpp index 30058c571f..2a8eb38ef9 100644 --- a/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.hpp +++ b/src/backends/neon/workloads/NeonL2NormalizationFloatWorkload.hpp @@ -5,7 +5,10 @@ #pragma once -#include +#include + +#include +#include #include #include @@ -25,7 +28,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEL2NormalizeLayer m_Layer; + std::unique_ptr m_Layer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonMergerWorkload.cpp b/src/backends/neon/workloads/NeonMergerWorkload.cpp index f82e24453a..be096b4b25 100644 --- a/src/backends/neon/workloads/NeonMergerWorkload.cpp +++ b/src/backends/neon/workloads/NeonMergerWorkload.cpp @@ -4,11 +4,14 @@ // #include "NeonMergerWorkload.hpp" -#include + +#include "NeonWorkloadUtils.hpp" + #include #include #include +#include namespace armnn { @@ -66,9 +69,11 @@ const MergerQueueDescriptor& descriptor, const WorkloadInfo& info) arm_compute::DataLayoutDimension aclAxis = arm_compute::DataLayoutDimension::WIDTH; - m_Layer.configure(aclInputs, &output, aclAxis); + auto layer = std::make_unique(); + layer->configure(aclInputs, &output, aclAxis); + m_Layer.reset(layer.release()); - m_Layer.prepare(); + m_Layer->prepare(); } void NeonMergerWorkload::Execute() const @@ -76,7 +81,7 @@ void NeonMergerWorkload::Execute() const if (m_Execute) { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMergerWorkload_Execute"); - m_Layer.run(); + m_Layer->run(); } } diff --git a/src/backends/neon/workloads/NeonMergerWorkload.hpp b/src/backends/neon/workloads/NeonMergerWorkload.hpp index a4f36d18bc..3432c626cb 100644 --- a/src/backends/neon/workloads/NeonMergerWorkload.hpp +++ b/src/backends/neon/workloads/NeonMergerWorkload.hpp @@ -6,7 +6,11 @@ #pragma once #include -#include + +#include +#include +# +#include namespace armnn { @@ -23,7 +27,7 @@ public: void Execute() const override; private: - mutable arm_compute::NEConcatenateLayer m_Layer; + std::unique_ptr m_Layer; bool m_Execute; }; diff --git a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.cpp b/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.cpp index c4241ece19..778e78213c 100644 --- a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.cpp +++ b/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.cpp @@ -5,6 +5,9 @@ #include "NeonMultiplicationFloatWorkload.hpp" +#include "NeonWorkloadUtils.hpp" + +#include namespace armnn { @@ -41,18 +44,20 @@ NeonMultiplicationFloatWorkload::NeonMultiplicationFloatWorkload(const Multiplic // 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. - m_PixelWiseMultiplication.configure(&input1, - &input2, - &output, - 1.0f, - arm_compute::ConvertPolicy::SATURATE, - arm_compute::RoundingPolicy::TO_ZERO); + auto layer = std::make_unique(); + layer->configure(&input1, + &input2, + &output, + 1.0f, + arm_compute::ConvertPolicy::SATURATE, + arm_compute::RoundingPolicy::TO_ZERO); + m_PixelWiseMultiplication.reset(layer.release()); } void NeonMultiplicationFloatWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationFloatWorkload_Execute"); - m_PixelWiseMultiplication.run(); + m_PixelWiseMultiplication->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.hpp b/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.hpp index 8fa3171110..a65ad4ec4c 100644 --- a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.hpp +++ b/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.hpp @@ -5,7 +5,12 @@ #pragma once -#include +#include + +#include +#include + +#include namespace armnn { @@ -20,7 +25,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEPixelWiseMultiplication m_PixelWiseMultiplication; + std::unique_ptr m_PixelWiseMultiplication; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonNormalizationFloatWorkload.cpp b/src/backends/neon/workloads/NeonNormalizationFloatWorkload.cpp index 854ecd3c59..92c0396d86 100644 --- a/src/backends/neon/workloads/NeonNormalizationFloatWorkload.cpp +++ b/src/backends/neon/workloads/NeonNormalizationFloatWorkload.cpp @@ -4,10 +4,13 @@ // #include "NeonNormalizationFloatWorkload.hpp" -#include + +#include "NeonWorkloadUtils.hpp" #include #include +#include + using namespace armnn::armcomputetensorutils; namespace armnn @@ -57,7 +60,6 @@ NeonNormalizationFloatWorkload::NeonNormalizationFloatWorkload(const Normalizati const WorkloadInfo& info, std::shared_ptr& memoryManager) : FloatWorkload(descriptor, info) - , m_NormalizationLayer(memoryManager) { m_Data.ValidateInputsOutputs("NeonNormalizationFloatWorkload", 1, 1); std::string reasonIfUnsupported; @@ -89,14 +91,15 @@ NeonNormalizationFloatWorkload::NeonNormalizationFloatWorkload(const Normalizati m_Data.m_Parameters.m_Beta, m_Data.m_Parameters.m_K, false); - - m_NormalizationLayer.configure(&input, &output, normalizationInfo); + auto layer = std::make_unique(memoryManager); + layer->configure(&input, &output, normalizationInfo); + m_NormalizationLayer.reset(layer.release()); } void NeonNormalizationFloatWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonNormalizationFloatWorkload_Execute"); - m_NormalizationLayer.run(); + m_NormalizationLayer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonNormalizationFloatWorkload.hpp b/src/backends/neon/workloads/NeonNormalizationFloatWorkload.hpp index 89eba573da..17bbeb41ab 100644 --- a/src/backends/neon/workloads/NeonNormalizationFloatWorkload.hpp +++ b/src/backends/neon/workloads/NeonNormalizationFloatWorkload.hpp @@ -5,9 +5,14 @@ #pragma once -#include +#include + +#include +#include #include +#include + namespace armnn { @@ -23,7 +28,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NENormalizationLayer m_NormalizationLayer; + std::unique_ptr m_NormalizationLayer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonPooling2dWorkload.cpp b/src/backends/neon/workloads/NeonPooling2dWorkload.cpp index 9c8f71ad19..75bceb1bc7 100644 --- a/src/backends/neon/workloads/NeonPooling2dWorkload.cpp +++ b/src/backends/neon/workloads/NeonPooling2dWorkload.cpp @@ -4,11 +4,15 @@ // #include "NeonPooling2dWorkload.hpp" -#include + +#include "NeonWorkloadUtils.hpp" + #include #include #include +#include + namespace armnn { using namespace armcomputetensorutils; @@ -42,13 +46,15 @@ NeonPooling2dWorkload::NeonPooling2dWorkload( arm_compute::PoolingLayerInfo layerInfo = BuildArmComputePoolingLayerInfo(m_Data.m_Parameters); - m_PoolingLayer.configure(&input, &output, layerInfo); + auto layer = std::make_unique(); + layer->configure(&input, &output, layerInfo); + m_PoolingLayer.reset(layer.release()); } void NeonPooling2dWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonPooling2dWorkload_Execute"); - m_PoolingLayer.run(); + m_PoolingLayer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonPooling2dWorkload.hpp b/src/backends/neon/workloads/NeonPooling2dWorkload.hpp index b2379f7f53..b0e3aa8c59 100644 --- a/src/backends/neon/workloads/NeonPooling2dWorkload.hpp +++ b/src/backends/neon/workloads/NeonPooling2dWorkload.hpp @@ -5,7 +5,12 @@ #pragma once -#include +#include + +#include +#include + +#include namespace armnn { @@ -24,7 +29,7 @@ public: void Execute() const override; private: - mutable arm_compute::NEPoolingLayer m_PoolingLayer; + std::unique_ptr m_PoolingLayer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonReshapeWorkload.cpp b/src/backends/neon/workloads/NeonReshapeWorkload.cpp index c2dcdd500c..40fbef6520 100644 --- a/src/backends/neon/workloads/NeonReshapeWorkload.cpp +++ b/src/backends/neon/workloads/NeonReshapeWorkload.cpp @@ -5,6 +5,12 @@ #include "NeonReshapeWorkload.hpp" +#include "NeonWorkloadUtils.hpp" + +#include + +#include + namespace armnn { @@ -17,13 +23,15 @@ NeonReshapeWorkload::NeonReshapeWorkload(const ReshapeQueueDescriptor& descripto arm_compute::ITensor& input = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); arm_compute::ITensor& output = boost::polymorphic_downcast(m_Data.m_Outputs[0])->GetTensor(); - m_Layer.configure(&input, &output); + auto layer = std::make_unique(); + layer->configure(&input, &output); + m_Layer.reset(layer.release()); } void NeonReshapeWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonReshapeWorkload_Execute"); - m_Layer.run(); + m_Layer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonReshapeWorkload.hpp b/src/backends/neon/workloads/NeonReshapeWorkload.hpp index 38b6c510d2..2202463928 100644 --- a/src/backends/neon/workloads/NeonReshapeWorkload.hpp +++ b/src/backends/neon/workloads/NeonReshapeWorkload.hpp @@ -5,7 +5,11 @@ #pragma once -#include +#include + +#include + +#include namespace armnn { @@ -18,7 +22,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEReshapeLayer m_Layer; + std::unique_ptr m_Layer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.cpp b/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.cpp index 434de874ae..b229bc48a2 100644 --- a/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.cpp +++ b/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.cpp @@ -7,6 +7,8 @@ #include +#include + namespace armnn { diff --git a/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.hpp b/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.hpp index 6e96c2d2b4..6eecb9787d 100644 --- a/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.hpp +++ b/src/backends/neon/workloads/NeonSoftmaxBaseWorkload.hpp @@ -5,7 +5,8 @@ #pragma once -#include +#include +#include namespace armnn { diff --git a/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.cpp b/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.cpp index 92e5139c1a..d9c78bbd43 100644 --- a/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.cpp +++ b/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.cpp @@ -5,13 +5,16 @@ #include "NeonSoftmaxFloatWorkload.hpp" +#include "NeonWorkloadUtils.hpp" + +#include + namespace armnn { NeonSoftmaxFloatWorkload::NeonSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info, std::shared_ptr& memoryManager) : FloatWorkload(descriptor, info) - , m_SoftmaxLayer(memoryManager) { m_Data.ValidateInputsOutputs("NeonSoftmaxFloatWorkload", 1, 1); @@ -19,13 +22,15 @@ NeonSoftmaxFloatWorkload::NeonSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& arm_compute::ITensor& input = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); arm_compute::ITensor& output = boost::polymorphic_downcast(m_Data.m_Outputs[0])->GetTensor(); - m_SoftmaxLayer.configure(&input, &output, m_Data.m_Parameters.m_Beta); + auto layer = std::make_unique(memoryManager); + layer->configure(&input, &output, m_Data.m_Parameters.m_Beta); + m_SoftmaxLayer.reset(layer.release()); } void NeonSoftmaxFloatWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSoftmaxFloatWorkload_Execute"); - m_SoftmaxLayer.run(); + m_SoftmaxLayer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.hpp b/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.hpp index 9c11b27bb5..77f2cc3d01 100644 --- a/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.hpp +++ b/src/backends/neon/workloads/NeonSoftmaxFloatWorkload.hpp @@ -5,7 +5,9 @@ #pragma once -#include +#include + +#include #include #include @@ -21,7 +23,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NESoftmaxLayer m_SoftmaxLayer; + std::unique_ptr m_SoftmaxLayer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonSoftmaxUint8Workload.cpp b/src/backends/neon/workloads/NeonSoftmaxUint8Workload.cpp index cff869c9b7..f780589075 100644 --- a/src/backends/neon/workloads/NeonSoftmaxUint8Workload.cpp +++ b/src/backends/neon/workloads/NeonSoftmaxUint8Workload.cpp @@ -5,6 +5,10 @@ #include "NeonSoftmaxUint8Workload.hpp" +#include "NeonWorkloadUtils.hpp" + +#include + namespace armnn { @@ -12,7 +16,6 @@ NeonSoftmaxUint8Workload::NeonSoftmaxUint8Workload(const SoftmaxQueueDescriptor& const WorkloadInfo& info, std::shared_ptr& memoryManager) : Uint8Workload(descriptor, info) - , m_SoftmaxLayer(memoryManager) { m_Data.ValidateInputsOutputs("NeonSoftmaxUint8Workload", 1, 1); @@ -27,14 +30,16 @@ NeonSoftmaxUint8Workload::NeonSoftmaxUint8Workload(const SoftmaxQueueDescriptor& "Invalid quantization for output. Only scale = 1.0f / 256.0f and offset = 0 supported"); } - m_SoftmaxLayer.configure(&input, &output, descriptor.m_Parameters.m_Beta); + auto layer = std::make_unique(memoryManager); + layer->configure(&input, &output, descriptor.m_Parameters.m_Beta); + m_SoftmaxLayer.reset(layer.release()); } void NeonSoftmaxUint8Workload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSoftmaxUint8Workload_Execute"); - m_SoftmaxLayer.run(); + m_SoftmaxLayer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonSoftmaxUint8Workload.hpp b/src/backends/neon/workloads/NeonSoftmaxUint8Workload.hpp index b3bcbf38b5..c5692084c9 100644 --- a/src/backends/neon/workloads/NeonSoftmaxUint8Workload.hpp +++ b/src/backends/neon/workloads/NeonSoftmaxUint8Workload.hpp @@ -5,9 +5,13 @@ #pragma once -#include +#include + +#include #include +#include + namespace armnn { @@ -19,7 +23,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NESoftmaxLayer m_SoftmaxLayer; + std::unique_ptr m_SoftmaxLayer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.cpp b/src/backends/neon/workloads/NeonSubtractionFloatWorkload.cpp index 1eae0a49ce..e39f8aa18e 100644 --- a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.cpp +++ b/src/backends/neon/workloads/NeonSubtractionFloatWorkload.cpp @@ -4,9 +4,13 @@ // #include "NeonSubtractionFloatWorkload.hpp" + +#include "NeonWorkloadUtils.hpp" #include #include +#include + namespace armnn { @@ -34,13 +38,15 @@ NeonSubtractionFloatWorkload::NeonSubtractionFloatWorkload(const SubtractionQueu arm_compute::ITensor& input2 = boost::polymorphic_downcast(m_Data.m_Inputs[1])->GetTensor(); arm_compute::ITensor& output = boost::polymorphic_downcast(m_Data.m_Outputs[0])->GetTensor(); - m_SubLayer.configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE); + auto layer = std::make_unique(); + layer->configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE); + m_SubLayer.reset(layer.release()); } void NeonSubtractionFloatWorkload::Execute() const { ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSubtractionFloatWorkload_Execute"); - m_SubLayer.run(); + m_SubLayer->run(); } } //namespace armnn diff --git a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.hpp b/src/backends/neon/workloads/NeonSubtractionFloatWorkload.hpp index 09016993e0..5dce112299 100644 --- a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.hpp +++ b/src/backends/neon/workloads/NeonSubtractionFloatWorkload.hpp @@ -5,7 +5,12 @@ #pragma once -#include +#include + +#include +#include + +#include namespace armnn { @@ -21,7 +26,7 @@ public: virtual void Execute() const override; private: - mutable arm_compute::NEArithmeticSubtraction m_SubLayer; + std::unique_ptr m_SubLayer; }; } //namespace armnn diff --git a/src/backends/neon/workloads/NeonWorkloadUtils.hpp b/src/backends/neon/workloads/NeonWorkloadUtils.hpp index 17e14cdd99..22ffece6a2 100644 --- a/src/backends/neon/workloads/NeonWorkloadUtils.hpp +++ b/src/backends/neon/workloads/NeonWorkloadUtils.hpp @@ -9,7 +9,6 @@ #include #include #include -#include #include -- cgit v1.2.1