From 9e53a35b66b1ec7ceee7c712380a13596175b83b Mon Sep 17 00:00:00 2001 From: arovir01 Date: Fri, 31 Aug 2018 15:26:35 +0100 Subject: IVGCVSW-1784: Rename float32 workloads for ACL Change-Id: I98bdfe9cb12c663d1d5cfa456e2cc967d70ab22b --- .../NeonActivationFloat32Workload.cpp | 57 ------------- .../NeonActivationFloat32Workload.hpp | 29 ------- .../NeonWorkloads/NeonActivationFloatWorkload.cpp | 57 +++++++++++++ .../NeonWorkloads/NeonActivationFloatWorkload.hpp | 29 +++++++ .../NeonWorkloads/NeonAdditionFloat32Workload.cpp | 48 ----------- .../NeonWorkloads/NeonAdditionFloat32Workload.hpp | 30 ------- .../NeonWorkloads/NeonAdditionFloatWorkload.cpp | 48 +++++++++++ .../NeonWorkloads/NeonAdditionFloatWorkload.hpp | 30 +++++++ .../NeonBatchNormalizationFloat32Workload.cpp | 96 ---------------------- .../NeonBatchNormalizationFloat32Workload.hpp | 42 ---------- .../NeonBatchNormalizationFloatWorkload.cpp | 96 ++++++++++++++++++++++ .../NeonBatchNormalizationFloatWorkload.hpp | 42 ++++++++++ .../NeonWorkloads/NeonConstantFloat32Workload.cpp | 17 ---- .../NeonWorkloads/NeonConstantFloat32Workload.hpp | 20 ----- .../NeonWorkloads/NeonConstantFloatWorkload.cpp | 17 ++++ .../NeonWorkloads/NeonConstantFloatWorkload.hpp | 20 +++++ .../NeonConvolution2dFloat32Workload.cpp | 40 --------- .../NeonConvolution2dFloat32Workload.hpp | 29 ------- .../NeonConvolution2dFloatWorkload.cpp | 40 +++++++++ .../NeonConvolution2dFloatWorkload.hpp | 29 +++++++ .../NeonDepthwiseConvolutionFloat32Workload.cpp | 94 --------------------- .../NeonDepthwiseConvolutionFloat32Workload.hpp | 33 -------- .../NeonDepthwiseConvolutionFloatWorkload.cpp | 94 +++++++++++++++++++++ .../NeonDepthwiseConvolutionFloatWorkload.hpp | 33 ++++++++ .../NeonWorkloads/NeonFloorFloat32Workload.cpp | 30 ------- .../NeonWorkloads/NeonFloorFloat32Workload.hpp | 27 ------ .../NeonWorkloads/NeonFloorFloatWorkload.cpp | 30 +++++++ .../NeonWorkloads/NeonFloorFloatWorkload.hpp | 27 ++++++ .../NeonFullyConnectedFloat32Workload.cpp | 96 ---------------------- .../NeonFullyConnectedFloat32Workload.hpp | 40 --------- .../NeonFullyConnectedFloatWorkload.cpp | 96 ++++++++++++++++++++++ .../NeonFullyConnectedFloatWorkload.hpp | 40 +++++++++ .../NeonL2NormalizationFloat32Workload.cpp | 42 ---------- .../NeonL2NormalizationFloat32Workload.hpp | 33 -------- .../NeonL2NormalizationFloatWorkload.cpp | 42 ++++++++++ .../NeonL2NormalizationFloatWorkload.hpp | 33 ++++++++ .../NeonWorkloads/NeonLstmFloat32Workload.cpp | 22 ----- .../NeonWorkloads/NeonLstmFloat32Workload.hpp | 20 ----- .../NeonWorkloads/NeonLstmFloatWorkload.cpp | 22 +++++ .../NeonWorkloads/NeonLstmFloatWorkload.hpp | 20 +++++ .../NeonWorkloads/NeonMergerFloat32Workload.cpp | 17 ---- .../NeonWorkloads/NeonMergerFloat32Workload.hpp | 20 ----- .../NeonWorkloads/NeonMergerFloatWorkload.cpp | 17 ++++ .../NeonWorkloads/NeonMergerFloatWorkload.hpp | 20 +++++ .../NeonMultiplicationFloat32Workload.cpp | 60 -------------- .../NeonMultiplicationFloat32Workload.hpp | 30 ------- .../NeonMultiplicationFloatWorkload.cpp | 60 ++++++++++++++ .../NeonMultiplicationFloatWorkload.hpp | 30 +++++++ .../NeonNormalizationFloat32Workload.cpp | 70 ---------------- .../NeonNormalizationFloat32Workload.hpp | 34 -------- .../NeonNormalizationFloatWorkload.cpp | 70 ++++++++++++++++ .../NeonNormalizationFloatWorkload.hpp | 34 ++++++++ .../NeonWorkloads/NeonPooling2dFloat32Workload.cpp | 27 ------ .../NeonWorkloads/NeonPooling2dFloat32Workload.hpp | 25 ------ .../NeonWorkloads/NeonPooling2dFloatWorkload.cpp | 27 ++++++ .../NeonWorkloads/NeonPooling2dFloatWorkload.hpp | 25 ++++++ .../NeonWorkloads/NeonReshapeFloat32Workload.cpp | 32 -------- .../NeonWorkloads/NeonReshapeFloat32Workload.hpp | 29 ------- .../NeonWorkloads/NeonReshapeFloatWorkload.cpp | 32 ++++++++ .../NeonWorkloads/NeonReshapeFloatWorkload.hpp | 29 +++++++ .../NeonWorkloads/NeonSoftmaxFloat32Workload.cpp | 32 -------- .../NeonWorkloads/NeonSoftmaxFloat32Workload.hpp | 29 ------- .../NeonWorkloads/NeonSoftmaxFloatWorkload.cpp | 32 ++++++++ .../NeonWorkloads/NeonSoftmaxFloatWorkload.hpp | 29 +++++++ .../NeonWorkloads/NeonSplitterFloat32Workload.cpp | 17 ---- .../NeonWorkloads/NeonSplitterFloat32Workload.hpp | 20 ----- .../NeonWorkloads/NeonSplitterFloatWorkload.cpp | 17 ++++ .../NeonWorkloads/NeonSplitterFloatWorkload.hpp | 20 +++++ 68 files changed, 1287 insertions(+), 1287 deletions(-) delete mode 100644 src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.cpp delete mode 100644 src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.cpp create mode 100644 src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp (limited to 'src/armnn/backends/NeonWorkloads') diff --git a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.cpp deleted file mode 100644 index 711bfceeaf..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.cpp +++ /dev/null @@ -1,57 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonActivationFloat32Workload.hpp" -#include "backends/ArmComputeUtils.hpp" - - -namespace armnn -{ - -arm_compute::Status NeonActivationWorkloadValidate(const TensorInfo& input, - const TensorInfo& output, - const ActivationDescriptor& descriptor) -{ - const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input); - const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); - - const arm_compute::ActivationLayerInfo activationLayerInfo = - ConvertActivationDescriptorToAclActivationLayerInfo(descriptor); - - if (input.GetDataType() == DataType::QuantisedAsymm8 && - activationLayerInfo.activation() == arm_compute::ActivationLayerInfo::ActivationFunction::LOGISTIC) - { - return arm_compute::Status{arm_compute::ErrorCode::RUNTIME_ERROR, - "Neon: Logistic Activations unsupported with QAsymm8 data type."}; - } - - return arm_compute::NEActivationLayer::validate(&aclInput, - &aclOutput, - activationLayerInfo); -} - -NeonActivationFloat32Workload::NeonActivationFloat32Workload(const ActivationQueueDescriptor& descriptor, - const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - m_Data.ValidateInputsOutputs("NeonActivationFloat32Workload", 1, 1); - - const arm_compute::ActivationLayerInfo activationLayerInfo = - ConvertActivationDescriptorToAclActivationLayerInfo(m_Data.m_Parameters); - - 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); -} - -void NeonActivationFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonActivationFloat32Workload_Execute"); - m_ActivationLayer.run(); -} - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.hpp deleted file mode 100644 index 0d26b3b39f..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ - -arm_compute::Status NeonActivationWorkloadValidate(const TensorInfo& input, - const TensorInfo& output, - const ActivationDescriptor& descriptor); - -class NeonActivationFloat32Workload : public FloatWorkload -{ -public: - NeonActivationFloat32Workload(const ActivationQueueDescriptor& descriptor, const WorkloadInfo& info); - void Execute() const override; - -private: - mutable arm_compute::NEActivationLayer m_ActivationLayer; -}; -} //namespace armnn - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.cpp new file mode 100644 index 0000000000..e3524dced6 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.cpp @@ -0,0 +1,57 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonActivationFloatWorkload.hpp" +#include "backends/ArmComputeUtils.hpp" + + +namespace armnn +{ + +arm_compute::Status NeonActivationWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const ActivationDescriptor& descriptor) +{ + const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input); + const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); + + const arm_compute::ActivationLayerInfo activationLayerInfo = + ConvertActivationDescriptorToAclActivationLayerInfo(descriptor); + + if (input.GetDataType() == DataType::QuantisedAsymm8 && + activationLayerInfo.activation() == arm_compute::ActivationLayerInfo::ActivationFunction::LOGISTIC) + { + return arm_compute::Status{arm_compute::ErrorCode::RUNTIME_ERROR, + "Neon: Logistic Activations unsupported with QAsymm8 data type."}; + } + + return arm_compute::NEActivationLayer::validate(&aclInput, + &aclOutput, + activationLayerInfo); +} + +NeonActivationFloatWorkload::NeonActivationFloatWorkload(const ActivationQueueDescriptor& descriptor, + const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonActivationFloatWorkload", 1, 1); + + const arm_compute::ActivationLayerInfo activationLayerInfo = + ConvertActivationDescriptorToAclActivationLayerInfo(m_Data.m_Parameters); + + 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); +} + +void NeonActivationFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonActivationFloatWorkload_Execute"); + m_ActivationLayer.run(); +} + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.hpp new file mode 100644 index 0000000000..c9f4bab5f0 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.hpp @@ -0,0 +1,29 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ + +arm_compute::Status NeonActivationWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const ActivationDescriptor& descriptor); + +class NeonActivationFloatWorkload : public FloatWorkload +{ +public: + NeonActivationFloatWorkload(const ActivationQueueDescriptor& descriptor, const WorkloadInfo& info); + void Execute() const override; + +private: + mutable arm_compute::NEActivationLayer m_ActivationLayer; +}; +} //namespace armnn + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.cpp deleted file mode 100644 index f26e42aff9..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.cpp +++ /dev/null @@ -1,48 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonAdditionFloat32Workload.hpp" -#include "backends/ArmComputeTensorUtils.hpp" -#include "backends/CpuTensorHandle.hpp" - -namespace armnn -{ - -arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output) -{ - const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0); - const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1); - const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); - - return arm_compute::NEArithmeticAddition::validate(&aclInput0, - &aclInput1, - &aclOutput, - arm_compute::ConvertPolicy::SATURATE); -} - - -NeonAdditionFloat32Workload::NeonAdditionFloat32Workload(const AdditionQueueDescriptor& descriptor, - const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - m_Data.ValidateInputsOutputs("NeonAdditionFloat32Workload", 2, 1); - - arm_compute::ITensor& input1 = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); - 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); -} - -void NeonAdditionFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonAdditionFloat32Workload_Execute"); - m_AddLayer.run(); -} - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp deleted file mode 100644 index dae66bb69d..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp +++ /dev/null @@ -1,30 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ - -arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output); - -class NeonAdditionFloat32Workload : public FloatWorkload -{ -public: - NeonAdditionFloat32Workload(const AdditionQueueDescriptor& descriptor, const WorkloadInfo& info); - virtual void Execute() const override; - -private: - mutable arm_compute::NEArithmeticAddition m_AddLayer; -}; - -} //namespace armnn - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.cpp new file mode 100644 index 0000000000..1c1e65c206 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.cpp @@ -0,0 +1,48 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonAdditionFloatWorkload.hpp" +#include "backends/ArmComputeTensorUtils.hpp" +#include "backends/CpuTensorHandle.hpp" + +namespace armnn +{ + +arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output) +{ + const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0); + const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1); + const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); + + return arm_compute::NEArithmeticAddition::validate(&aclInput0, + &aclInput1, + &aclOutput, + arm_compute::ConvertPolicy::SATURATE); +} + + +NeonAdditionFloatWorkload::NeonAdditionFloatWorkload(const AdditionQueueDescriptor& descriptor, + const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonAdditionFloatWorkload", 2, 1); + + arm_compute::ITensor& input1 = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); + 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); +} + +void NeonAdditionFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonAdditionFloatWorkload_Execute"); + m_AddLayer.run(); +} + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp new file mode 100644 index 0000000000..efab230925 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp @@ -0,0 +1,30 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ + +arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output); + +class NeonAdditionFloatWorkload : public FloatWorkload +{ +public: + NeonAdditionFloatWorkload(const AdditionQueueDescriptor& descriptor, const WorkloadInfo& info); + virtual void Execute() const override; + +private: + mutable arm_compute::NEArithmeticAddition m_AddLayer; +}; + +} //namespace armnn + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.cpp deleted file mode 100644 index ca5c8202cd..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.cpp +++ /dev/null @@ -1,96 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonBatchNormalizationFloat32Workload.hpp" -#include "backends/CpuTensorHandle.hpp" -#include "backends/ArmComputeTensorUtils.hpp" -#include "../../../../include/armnn/ArmNN.hpp" - -namespace armnn -{ -using namespace armcomputetensorutils; - - -arm_compute::Status NeonBatchNormalizationValidate(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& mean, - const TensorInfo& var, - const TensorInfo& beta, - const TensorInfo& gamma, - const BatchNormalizationDescriptor& descriptor) -{ - const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input); - const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output); - const arm_compute::TensorInfo aclMeanInfo = BuildArmComputeTensorInfo(mean); - const arm_compute::TensorInfo aclVarInfo = BuildArmComputeTensorInfo(var); - const arm_compute::TensorInfo aclBetaInfo = BuildArmComputeTensorInfo(beta); - const arm_compute::TensorInfo aclGammaInfo = BuildArmComputeTensorInfo(gamma); - - return arm_compute::NEBatchNormalizationLayer::validate(&aclInputInfo, - &aclOutputInfo, - &aclMeanInfo, - &aclVarInfo, - &aclBetaInfo, - &aclGammaInfo, - descriptor.m_Eps); -} - -NeonBatchNormalizationFloat32Workload::NeonBatchNormalizationFloat32Workload( - const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - m_Data.ValidateInputsOutputs("NeonBatchNormalizationFloat32Workload", 1, 1); - - 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_Mean = std::make_unique(); - BuildArmComputeTensor(*m_Mean, m_Data.m_Mean->GetTensorInfo()); - - m_Variance = std::make_unique(); - BuildArmComputeTensor(*m_Variance, m_Data.m_Variance->GetTensorInfo()); - - m_Gamma = std::make_unique(); - BuildArmComputeTensor(*m_Gamma, m_Data.m_Gamma->GetTensorInfo()); - - 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); - - InitializeArmComputeTensorDataForFloatTypes(*m_Mean, m_Data.m_Mean); - InitializeArmComputeTensorDataForFloatTypes(*m_Variance, m_Data.m_Variance); - InitializeArmComputeTensorDataForFloatTypes(*m_Gamma, m_Data.m_Gamma); - InitializeArmComputeTensorDataForFloatTypes(*m_Beta, m_Data.m_Beta); - - // 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(); - FreeUnusedTensors(); -} - -void NeonBatchNormalizationFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonBatchNormalizationFloat32Workload_Execute"); - m_Layer.run(); -} - -void NeonBatchNormalizationFloat32Workload::FreeUnusedTensors() -{ - FreeTensorIfUnused(m_Mean); - FreeTensorIfUnused(m_Variance); - FreeTensorIfUnused(m_Gamma); - FreeTensorIfUnused(m_Beta); -} - -} //namespace armnn - - diff --git a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp deleted file mode 100644 index 5eb5601f26..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ - -arm_compute::Status NeonBatchNormalizationValidate(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& mean, - const TensorInfo& var, - const TensorInfo& beta, - const TensorInfo& gamma, - const BatchNormalizationDescriptor& descriptor); - -class NeonBatchNormalizationFloat32Workload : public FloatWorkload -{ -public: - NeonBatchNormalizationFloat32Workload(const BatchNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info); - virtual void Execute() const override; - -private: - mutable arm_compute::NEBatchNormalizationLayer m_Layer; - - std::unique_ptr m_Mean; - std::unique_ptr m_Variance; - std::unique_ptr m_Gamma; - std::unique_ptr m_Beta; - - void FreeUnusedTensors(); -}; - -} //namespace armnn - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.cpp new file mode 100644 index 0000000000..f24ff796cf --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.cpp @@ -0,0 +1,96 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonBatchNormalizationFloatWorkload.hpp" +#include "backends/CpuTensorHandle.hpp" +#include "backends/ArmComputeTensorUtils.hpp" +#include "../../../../include/armnn/ArmNN.hpp" + +namespace armnn +{ +using namespace armcomputetensorutils; + + +arm_compute::Status NeonBatchNormalizationValidate(const TensorInfo& input, + const TensorInfo& output, + const TensorInfo& mean, + const TensorInfo& var, + const TensorInfo& beta, + const TensorInfo& gamma, + const BatchNormalizationDescriptor& descriptor) +{ + const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input); + const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output); + const arm_compute::TensorInfo aclMeanInfo = BuildArmComputeTensorInfo(mean); + const arm_compute::TensorInfo aclVarInfo = BuildArmComputeTensorInfo(var); + const arm_compute::TensorInfo aclBetaInfo = BuildArmComputeTensorInfo(beta); + const arm_compute::TensorInfo aclGammaInfo = BuildArmComputeTensorInfo(gamma); + + return arm_compute::NEBatchNormalizationLayer::validate(&aclInputInfo, + &aclOutputInfo, + &aclMeanInfo, + &aclVarInfo, + &aclBetaInfo, + &aclGammaInfo, + descriptor.m_Eps); +} + +NeonBatchNormalizationFloatWorkload::NeonBatchNormalizationFloatWorkload( + const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonBatchNormalizationFloatWorkload", 1, 1); + + 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_Mean = std::make_unique(); + BuildArmComputeTensor(*m_Mean, m_Data.m_Mean->GetTensorInfo()); + + m_Variance = std::make_unique(); + BuildArmComputeTensor(*m_Variance, m_Data.m_Variance->GetTensorInfo()); + + m_Gamma = std::make_unique(); + BuildArmComputeTensor(*m_Gamma, m_Data.m_Gamma->GetTensorInfo()); + + 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); + + InitializeArmComputeTensorDataForFloatTypes(*m_Mean, m_Data.m_Mean); + InitializeArmComputeTensorDataForFloatTypes(*m_Variance, m_Data.m_Variance); + InitializeArmComputeTensorDataForFloatTypes(*m_Gamma, m_Data.m_Gamma); + InitializeArmComputeTensorDataForFloatTypes(*m_Beta, m_Data.m_Beta); + + // 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(); + FreeUnusedTensors(); +} + +void NeonBatchNormalizationFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonBatchNormalizationFloatWorkload_Execute"); + m_Layer.run(); +} + +void NeonBatchNormalizationFloatWorkload::FreeUnusedTensors() +{ + FreeTensorIfUnused(m_Mean); + FreeTensorIfUnused(m_Variance); + FreeTensorIfUnused(m_Gamma); + FreeTensorIfUnused(m_Beta); +} + +} //namespace armnn + + diff --git a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp new file mode 100644 index 0000000000..2844c650ca --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp @@ -0,0 +1,42 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ + +arm_compute::Status NeonBatchNormalizationValidate(const TensorInfo& input, + const TensorInfo& output, + const TensorInfo& mean, + const TensorInfo& var, + const TensorInfo& beta, + const TensorInfo& gamma, + const BatchNormalizationDescriptor& descriptor); + +class NeonBatchNormalizationFloatWorkload : public FloatWorkload +{ +public: + NeonBatchNormalizationFloatWorkload(const BatchNormalizationQueueDescriptor& descriptor, + const WorkloadInfo& info); + virtual void Execute() const override; + +private: + mutable arm_compute::NEBatchNormalizationLayer m_Layer; + + std::unique_ptr m_Mean; + std::unique_ptr m_Variance; + std::unique_ptr m_Gamma; + std::unique_ptr m_Beta; + + void FreeUnusedTensors(); +}; + +} //namespace armnn + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.cpp deleted file mode 100644 index 4e5d570a8e..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.cpp +++ /dev/null @@ -1,17 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonConstantFloat32Workload.hpp" - -namespace armnn -{ - -void NeonConstantFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConstantFloat32Workload_Execute"); - NeonBaseConstantWorkload::Execute(); -} - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.hpp deleted file mode 100644 index 050954df24..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include "NeonBaseConstantWorkload.hpp" - -namespace armnn -{ - -class NeonConstantFloat32Workload : public NeonBaseConstantWorkload -{ -public: - using NeonBaseConstantWorkload::NeonBaseConstantWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.cpp new file mode 100644 index 0000000000..49749a8b08 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.cpp @@ -0,0 +1,17 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonConstantFloatWorkload.hpp" + +namespace armnn +{ + +void NeonConstantFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConstantFloatWorkload_Execute"); + NeonBaseConstantWorkload::Execute(); +} + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.hpp new file mode 100644 index 0000000000..8ae0add2c8 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.hpp @@ -0,0 +1,20 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include "NeonBaseConstantWorkload.hpp" + +namespace armnn +{ + +class NeonConstantFloatWorkload : public NeonBaseConstantWorkload +{ +public: + using NeonBaseConstantWorkload::NeonBaseConstantWorkload; + virtual void Execute() const override; +}; + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.cpp deleted file mode 100644 index 18ec6ca2e7..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.cpp +++ /dev/null @@ -1,40 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonConvolution2dFloat32Workload.hpp" -#include "backends/CpuTensorHandle.hpp" -#include "backends/ArmComputeTensorUtils.hpp" -#include "backends/NeonLayerSupport.hpp" - -namespace armnn -{ -using namespace armcomputetensorutils; - -NeonConvolution2dFloat32Workload::NeonConvolution2dFloat32Workload(const Convolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info, std::shared_ptr& memoryManager) - : NeonConvolution2dBaseWorkload(descriptor, info, memoryManager) -{ - if (m_Data.m_Parameters.m_BiasEnabled) - { - InitializeArmComputeTensorDataForFloatTypes(*m_BiasTensor, m_Data.m_Bias); - } - - m_ConvolutionLayer->prepare(); - FreeUnusedTensors(); -} - -void NeonConvolution2dFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConvolution2dFloat32Workload_Execute"); - m_ConvolutionLayer->run(); -} - -void NeonConvolution2dFloat32Workload::ValidateData() const -{ - m_Data.ValidateInputsOutputs("NeonConvolution2dFloat32Workload", 1, 1); -} - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp deleted file mode 100644 index 0bb8d69d94..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include "NeonConvolution2dBaseWorkload.hpp" -#include - -#include "arm_compute/runtime/MemoryManagerOnDemand.h" - -#include - -namespace armnn -{ - -class NeonConvolution2dFloat32Workload : public NeonConvolution2dBaseWorkload -{ -public: - NeonConvolution2dFloat32Workload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info, - std::shared_ptr& memoryManager); - - void Execute() const override; - void ValidateData() const override; -}; - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.cpp new file mode 100644 index 0000000000..8037cb638f --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.cpp @@ -0,0 +1,40 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonConvolution2dFloatWorkload.hpp" +#include "backends/CpuTensorHandle.hpp" +#include "backends/ArmComputeTensorUtils.hpp" +#include "backends/NeonLayerSupport.hpp" + +namespace armnn +{ +using namespace armcomputetensorutils; + +NeonConvolution2dFloatWorkload::NeonConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor, + const WorkloadInfo& info, std::shared_ptr& memoryManager) + : NeonConvolution2dBaseWorkload(descriptor, info, memoryManager) +{ + if (m_Data.m_Parameters.m_BiasEnabled) + { + InitializeArmComputeTensorDataForFloatTypes(*m_BiasTensor, m_Data.m_Bias); + } + + m_ConvolutionLayer->prepare(); + FreeUnusedTensors(); +} + +void NeonConvolution2dFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConvolution2dFloatWorkload_Execute"); + m_ConvolutionLayer->run(); +} + +void NeonConvolution2dFloatWorkload::ValidateData() const +{ + m_Data.ValidateInputsOutputs("NeonConvolution2dFloatWorkload", 1, 1); +} + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp new file mode 100644 index 0000000000..1d08118b61 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp @@ -0,0 +1,29 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include "NeonConvolution2dBaseWorkload.hpp" +#include + +#include "arm_compute/runtime/MemoryManagerOnDemand.h" + +#include + +namespace armnn +{ + +class NeonConvolution2dFloatWorkload : public NeonConvolution2dBaseWorkload +{ +public: + NeonConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info, + std::shared_ptr& memoryManager); + + void Execute() const override; + void ValidateData() const override; +}; + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.cpp deleted file mode 100644 index f94cd903b6..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.cpp +++ /dev/null @@ -1,94 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonDepthwiseConvolutionFloat32Workload.hpp" -#include "backends/NeonLayerSupport.hpp" -#include "backends/CpuTensorHandle.hpp" -#include "backends/ArmComputeTensorUtils.hpp" - - -namespace armnn -{ -using namespace armcomputetensorutils; - -NeonDepthwiseConvolutionFloat32Workload::NeonDepthwiseConvolutionFloat32Workload( - const DepthwiseConvolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - const TensorInfo& weightInfo = m_Data.m_Weight->GetTensorInfo(); - - m_KernelTensor = std::make_unique(); - BuildArmComputeTensor(*m_KernelTensor, weightInfo); - - if (m_Data.m_Parameters.m_BiasEnabled) - { - m_BiasTensor = std::make_unique(); - BuildArmComputeTensor(*m_BiasTensor, m_Data.m_Bias->GetTensorInfo()); - } - - arm_compute::PadStrideInfo padStrideInfo(m_Data.m_Parameters.m_StrideX, - m_Data.m_Parameters.m_StrideY, - m_Data.m_Parameters.m_PadLeft, - m_Data.m_Parameters.m_PadRight, - m_Data.m_Parameters.m_PadTop, - m_Data.m_Parameters.m_PadBottom, - arm_compute::DimensionRoundingType::FLOOR); - - m_Data.ValidateInputsOutputs("NeonDepthwiseConvolutionFloat32Workload", 1, 1); - - arm_compute::ITensor& input = static_cast(m_Data.m_Inputs[0])->GetTensor(); - arm_compute::ITensor& output = static_cast(m_Data.m_Outputs[0])->GetTensor(); - - bool use3x3Optimisation = weightInfo.GetShape()[3] == 3 && weightInfo.GetShape()[2] == 3; - if (use3x3Optimisation) - { - m_pDepthwiseConvolutionLayer = std::make_unique(); - static_cast( - m_pDepthwiseConvolutionLayer.get())->configure(&input, - m_KernelTensor.get(), - m_BiasTensor.get(), - &output, - padStrideInfo); - } - else - { - m_pDepthwiseConvolutionLayer = std::make_unique(); - static_cast( - m_pDepthwiseConvolutionLayer.get())->configure(&input, - m_KernelTensor.get(), - m_BiasTensor.get(), - &output, - padStrideInfo); - } - - BOOST_ASSERT(m_pDepthwiseConvolutionLayer); - - InitializeArmComputeTensorDataForFloatTypes(*m_KernelTensor, m_Data.m_Weight); - - if (m_BiasTensor) - { - InitializeArmComputeTensorDataForFloatTypes(*m_BiasTensor, m_Data.m_Bias); - } - - m_pDepthwiseConvolutionLayer->prepare(); - FreeUnusedTensors(); -} - -void NeonDepthwiseConvolutionFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonDepthwiseConvolutionFloat32Workload_Execute"); - BOOST_ASSERT(m_pDepthwiseConvolutionLayer); - - m_pDepthwiseConvolutionLayer->run(); -} - -void NeonDepthwiseConvolutionFloat32Workload::FreeUnusedTensors() -{ - FreeTensorIfUnused(m_KernelTensor); - FreeTensorIfUnused(m_BiasTensor); -} - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp deleted file mode 100644 index ece9f1877b..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ - -class NeonDepthwiseConvolutionFloat32Workload : public FloatWorkload -{ -public: - NeonDepthwiseConvolutionFloat32Workload(const DepthwiseConvolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info); - virtual void Execute() const override; - -private: - mutable std::unique_ptr m_pDepthwiseConvolutionLayer; - - std::unique_ptr m_KernelTensor; - std::unique_ptr m_BiasTensor; - - void FreeUnusedTensors(); -}; - -} //namespace armnn - - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.cpp new file mode 100644 index 0000000000..96ca938242 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.cpp @@ -0,0 +1,94 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonDepthwiseConvolutionFloatWorkload.hpp" +#include "backends/NeonLayerSupport.hpp" +#include "backends/CpuTensorHandle.hpp" +#include "backends/ArmComputeTensorUtils.hpp" + + +namespace armnn +{ +using namespace armcomputetensorutils; + +NeonDepthwiseConvolutionFloatWorkload::NeonDepthwiseConvolutionFloatWorkload( + const DepthwiseConvolution2dQueueDescriptor& descriptor, + const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + const TensorInfo& weightInfo = m_Data.m_Weight->GetTensorInfo(); + + m_KernelTensor = std::make_unique(); + BuildArmComputeTensor(*m_KernelTensor, weightInfo); + + if (m_Data.m_Parameters.m_BiasEnabled) + { + m_BiasTensor = std::make_unique(); + BuildArmComputeTensor(*m_BiasTensor, m_Data.m_Bias->GetTensorInfo()); + } + + arm_compute::PadStrideInfo padStrideInfo(m_Data.m_Parameters.m_StrideX, + m_Data.m_Parameters.m_StrideY, + m_Data.m_Parameters.m_PadLeft, + m_Data.m_Parameters.m_PadRight, + m_Data.m_Parameters.m_PadTop, + m_Data.m_Parameters.m_PadBottom, + arm_compute::DimensionRoundingType::FLOOR); + + m_Data.ValidateInputsOutputs("NeonDepthwiseConvolutionFloatWorkload", 1, 1); + + arm_compute::ITensor& input = static_cast(m_Data.m_Inputs[0])->GetTensor(); + arm_compute::ITensor& output = static_cast(m_Data.m_Outputs[0])->GetTensor(); + + bool use3x3Optimisation = weightInfo.GetShape()[3] == 3 && weightInfo.GetShape()[2] == 3; + if (use3x3Optimisation) + { + m_pDepthwiseConvolutionLayer = std::make_unique(); + static_cast( + m_pDepthwiseConvolutionLayer.get())->configure(&input, + m_KernelTensor.get(), + m_BiasTensor.get(), + &output, + padStrideInfo); + } + else + { + m_pDepthwiseConvolutionLayer = std::make_unique(); + static_cast( + m_pDepthwiseConvolutionLayer.get())->configure(&input, + m_KernelTensor.get(), + m_BiasTensor.get(), + &output, + padStrideInfo); + } + + BOOST_ASSERT(m_pDepthwiseConvolutionLayer); + + InitializeArmComputeTensorDataForFloatTypes(*m_KernelTensor, m_Data.m_Weight); + + if (m_BiasTensor) + { + InitializeArmComputeTensorDataForFloatTypes(*m_BiasTensor, m_Data.m_Bias); + } + + m_pDepthwiseConvolutionLayer->prepare(); + FreeUnusedTensors(); +} + +void NeonDepthwiseConvolutionFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonDepthwiseConvolutionFloatWorkload_Execute"); + BOOST_ASSERT(m_pDepthwiseConvolutionLayer); + + m_pDepthwiseConvolutionLayer->run(); +} + +void NeonDepthwiseConvolutionFloatWorkload::FreeUnusedTensors() +{ + FreeTensorIfUnused(m_KernelTensor); + FreeTensorIfUnused(m_BiasTensor); +} + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp new file mode 100644 index 0000000000..670182eef0 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp @@ -0,0 +1,33 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ + +class NeonDepthwiseConvolutionFloatWorkload : public FloatWorkload +{ +public: + NeonDepthwiseConvolutionFloatWorkload(const DepthwiseConvolution2dQueueDescriptor& descriptor, + const WorkloadInfo& info); + virtual void Execute() const override; + +private: + mutable std::unique_ptr m_pDepthwiseConvolutionLayer; + + std::unique_ptr m_KernelTensor; + std::unique_ptr m_BiasTensor; + + void FreeUnusedTensors(); +}; + +} //namespace armnn + + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.cpp deleted file mode 100644 index c43cfa9c46..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.cpp +++ /dev/null @@ -1,30 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonFloorFloat32Workload.hpp" - -namespace armnn -{ -NeonFloorFloat32Workload::NeonFloorFloat32Workload(const FloorQueueDescriptor& descriptor, - const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - m_Data.ValidateInputsOutputs("NeonFloorFloat32Workload", 1, 1); - - 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); -} - -void NeonFloorFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFloorFloat32Workload_Execute"); - m_Layer.run(); -} -} //namespace armnn - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.hpp deleted file mode 100644 index 56680f1e39..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.hpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ - -class NeonFloorFloat32Workload : public FloatWorkload -{ -public: - NeonFloorFloat32Workload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info); - virtual void Execute() const override; - -private: - mutable arm_compute::NEFloor m_Layer; -}; - -} //namespace armnn - - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.cpp new file mode 100644 index 0000000000..4d2cb029f5 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.cpp @@ -0,0 +1,30 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonFloorFloatWorkload.hpp" + +namespace armnn +{ +NeonFloorFloatWorkload::NeonFloorFloatWorkload(const FloorQueueDescriptor& descriptor, + const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonFloorFloatWorkload", 1, 1); + + 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); +} + +void NeonFloorFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFloorFloatWorkload_Execute"); + m_Layer.run(); +} +} //namespace armnn + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.hpp new file mode 100644 index 0000000000..1443d9a613 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.hpp @@ -0,0 +1,27 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ + +class NeonFloorFloatWorkload : public FloatWorkload +{ +public: + NeonFloorFloatWorkload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info); + virtual void Execute() const override; + +private: + mutable arm_compute::NEFloor m_Layer; +}; + +} //namespace armnn + + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.cpp deleted file mode 100644 index c3af41e20d..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.cpp +++ /dev/null @@ -1,96 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonFullyConnectedFloat32Workload.hpp" - -#include "backends/ArmComputeTensorUtils.hpp" -#include "backends/ArmComputeUtils.hpp" -#include "backends/CpuTensorHandle.hpp" - -namespace armnn -{ -using namespace armcomputetensorutils; - -arm_compute::Status NeonFullyConnectedWorkloadValidate(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& weights, - const TensorInfo& biases, - const FullyConnectedDescriptor& descriptor) -{ - const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input); - const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output); - const arm_compute::TensorInfo aclWeights = BuildArmComputeTensorInfo(weights); - - arm_compute::TensorInfo aclBiases; - arm_compute::TensorInfo *optionalAclBiases = nullptr; - if (descriptor.m_BiasEnabled) - { - aclBiases = BuildArmComputeTensorInfo(biases); - optionalAclBiases = &aclBiases; - } - - const arm_compute::FullyConnectedLayerInfo fullyConnectedLayerInfo = - ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor); - - - return arm_compute::NEFullyConnectedLayer::validate(&aclInput, - &aclWeights, - optionalAclBiases, - &aclOutput, - fullyConnectedLayerInfo); -} - -NeonFullyConnectedFloat32Workload::NeonFullyConnectedFloat32Workload(const FullyConnectedQueueDescriptor& descriptor, - const WorkloadInfo& info, std::shared_ptr& memoryManager) - : FloatWorkload(descriptor, info) - , m_FullyConnectedLayer(memoryManager) -{ - m_Data.ValidateInputsOutputs("NeonFullyConnectedFloat32Workload", 1, 1); - - 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_WeightsTensor = std::make_unique(); - BuildArmComputeTensor(*m_WeightsTensor, m_Data.m_Weight->GetTensorInfo()); - - if (m_Data.m_Parameters.m_BiasEnabled) - { - m_BiasesTensor = std::make_unique(); - BuildArmComputeTensor(*m_BiasesTensor, m_Data.m_Bias->GetTensorInfo()); - } - - // 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); - - // Allocate - InitializeArmComputeTensorDataForFloatTypes(*m_WeightsTensor, m_Data.m_Weight); - - if (m_BiasesTensor) - { - InitializeArmComputeTensorDataForFloatTypes(*m_BiasesTensor, m_Data.m_Bias); - } - - // 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(); - FreeUnusedTensors(); -} - -void NeonFullyConnectedFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFullyConnectedFloat32Workload_Execute"); - m_FullyConnectedLayer.run(); -} - -void NeonFullyConnectedFloat32Workload::FreeUnusedTensors() -{ - FreeTensorIfUnused(m_WeightsTensor); - FreeTensorIfUnused(m_BiasesTensor); -} - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp deleted file mode 100644 index 684b5e0753..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp +++ /dev/null @@ -1,40 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -#include "arm_compute/runtime/MemoryManagerOnDemand.h" - -#include - -namespace armnn -{ - -arm_compute::Status NeonFullyConnectedWorkloadValidate(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& weights, - const TensorInfo& biases, - const FullyConnectedDescriptor& descriptor); - -class NeonFullyConnectedFloat32Workload : public FloatWorkload -{ -public: - NeonFullyConnectedFloat32Workload(const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info, - std::shared_ptr& memoryManager); - virtual void Execute() const override; - -private: - mutable arm_compute::NEFullyConnectedLayer m_FullyConnectedLayer; - - std::unique_ptr m_WeightsTensor; - std::unique_ptr m_BiasesTensor; - - void FreeUnusedTensors(); -}; - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.cpp new file mode 100644 index 0000000000..098d84bf0c --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.cpp @@ -0,0 +1,96 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonFullyConnectedFloatWorkload.hpp" + +#include "backends/ArmComputeTensorUtils.hpp" +#include "backends/ArmComputeUtils.hpp" +#include "backends/CpuTensorHandle.hpp" + +namespace armnn +{ +using namespace armcomputetensorutils; + +arm_compute::Status NeonFullyConnectedWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const TensorInfo& weights, + const TensorInfo& biases, + const FullyConnectedDescriptor& descriptor) +{ + const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input); + const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output); + const arm_compute::TensorInfo aclWeights = BuildArmComputeTensorInfo(weights); + + arm_compute::TensorInfo aclBiases; + arm_compute::TensorInfo *optionalAclBiases = nullptr; + if (descriptor.m_BiasEnabled) + { + aclBiases = BuildArmComputeTensorInfo(biases); + optionalAclBiases = &aclBiases; + } + + const arm_compute::FullyConnectedLayerInfo fullyConnectedLayerInfo = + ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor); + + + return arm_compute::NEFullyConnectedLayer::validate(&aclInput, + &aclWeights, + optionalAclBiases, + &aclOutput, + fullyConnectedLayerInfo); +} + +NeonFullyConnectedFloatWorkload::NeonFullyConnectedFloatWorkload(const FullyConnectedQueueDescriptor& descriptor, + const WorkloadInfo& info, std::shared_ptr& memoryManager) + : FloatWorkload(descriptor, info) + , m_FullyConnectedLayer(memoryManager) +{ + m_Data.ValidateInputsOutputs("NeonFullyConnectedFloatWorkload", 1, 1); + + 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_WeightsTensor = std::make_unique(); + BuildArmComputeTensor(*m_WeightsTensor, m_Data.m_Weight->GetTensorInfo()); + + if (m_Data.m_Parameters.m_BiasEnabled) + { + m_BiasesTensor = std::make_unique(); + BuildArmComputeTensor(*m_BiasesTensor, m_Data.m_Bias->GetTensorInfo()); + } + + // 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); + + // Allocate + InitializeArmComputeTensorDataForFloatTypes(*m_WeightsTensor, m_Data.m_Weight); + + if (m_BiasesTensor) + { + InitializeArmComputeTensorDataForFloatTypes(*m_BiasesTensor, m_Data.m_Bias); + } + + // 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(); + FreeUnusedTensors(); +} + +void NeonFullyConnectedFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFullyConnectedFloatWorkload_Execute"); + m_FullyConnectedLayer.run(); +} + +void NeonFullyConnectedFloatWorkload::FreeUnusedTensors() +{ + FreeTensorIfUnused(m_WeightsTensor); + FreeTensorIfUnused(m_BiasesTensor); +} + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp new file mode 100644 index 0000000000..1f4464f0e1 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp @@ -0,0 +1,40 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +#include "arm_compute/runtime/MemoryManagerOnDemand.h" + +#include + +namespace armnn +{ + +arm_compute::Status NeonFullyConnectedWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const TensorInfo& weights, + const TensorInfo& biases, + const FullyConnectedDescriptor& descriptor); + +class NeonFullyConnectedFloatWorkload : public FloatWorkload +{ +public: + NeonFullyConnectedFloatWorkload(const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info, + std::shared_ptr& memoryManager); + virtual void Execute() const override; + +private: + mutable arm_compute::NEFullyConnectedLayer m_FullyConnectedLayer; + + std::unique_ptr m_WeightsTensor; + std::unique_ptr m_BiasesTensor; + + void FreeUnusedTensors(); +}; + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.cpp deleted file mode 100644 index a3ae33f41f..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.cpp +++ /dev/null @@ -1,42 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonL2NormalizationFloat32Workload.hpp" -#include "backends/ArmComputeUtils.hpp" - -namespace armnn -{ - -arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo& input, - const TensorInfo& output) -{ - const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input); - const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); - - arm_compute::NormalizationLayerInfo normalizationInfo = - CreateAclNormalizationLayerInfoForL2Normalization(input); - - return arm_compute::NENormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo); -} - -NeonL2NormalizationFloat32Workload::NeonL2NormalizationFloat32Workload(const L2NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info, std::shared_ptr& memoryManager) - : FloatWorkload(descriptor, info) - , m_Layer(memoryManager) -{ - m_Data.ValidateInputsOutputs("NeonL2NormalizationFloat32Workload", 1, 1); - - 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, CreateAclNormalizationLayerInfoForL2Normalization(info.m_InputTensorInfos[0])); -} - -void NeonL2NormalizationFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonL2NormalizationFloat32Workload_Execute"); - m_Layer.run(); -} - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp deleted file mode 100644 index c3fcde5a57..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -#include "arm_compute/runtime/MemoryManagerOnDemand.h" - -#include - -namespace armnn -{ - -arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo& input, - const TensorInfo& output); - -class NeonL2NormalizationFloat32Workload : public FloatWorkload -{ -public: - NeonL2NormalizationFloat32Workload(const L2NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info, - std::shared_ptr& memoryManager); - virtual void Execute() const override; - -private: - // Purposely not a NEL2Normalize function. See constructor. - mutable arm_compute::NENormalizationLayer m_Layer; -}; - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.cpp new file mode 100644 index 0000000000..bf0ef01349 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.cpp @@ -0,0 +1,42 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonL2NormalizationFloatWorkload.hpp" +#include "backends/ArmComputeUtils.hpp" + +namespace armnn +{ + +arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo& input, + const TensorInfo& output) +{ + const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input); + const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); + + arm_compute::NormalizationLayerInfo normalizationInfo = + CreateAclNormalizationLayerInfoForL2Normalization(input); + + return arm_compute::NENormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo); +} + +NeonL2NormalizationFloatWorkload::NeonL2NormalizationFloatWorkload(const L2NormalizationQueueDescriptor& descriptor, + const WorkloadInfo& info, std::shared_ptr& memoryManager) + : FloatWorkload(descriptor, info) + , m_Layer(memoryManager) +{ + m_Data.ValidateInputsOutputs("NeonL2NormalizationFloatWorkload", 1, 1); + + 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, CreateAclNormalizationLayerInfoForL2Normalization(info.m_InputTensorInfos[0])); +} + +void NeonL2NormalizationFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonL2NormalizationFloatWorkload_Execute"); + m_Layer.run(); +} + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp new file mode 100644 index 0000000000..5edff075f6 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp @@ -0,0 +1,33 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +#include "arm_compute/runtime/MemoryManagerOnDemand.h" + +#include + +namespace armnn +{ + +arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo& input, + const TensorInfo& output); + +class NeonL2NormalizationFloatWorkload : public FloatWorkload +{ +public: + NeonL2NormalizationFloatWorkload(const L2NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info, + std::shared_ptr& memoryManager); + virtual void Execute() const override; + +private: + // Purposely not a NEL2Normalize function. See constructor. + mutable arm_compute::NENormalizationLayer m_Layer; +}; + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.cpp deleted file mode 100644 index ba1369e179..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.cpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonLstmFloat32Workload.hpp" - -namespace armnn -{ -NeonLstmFloat32Workload::NeonLstmFloat32Workload(const LstmQueueDescriptor& descriptor, - const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - m_Data.ValidateInputsOutputs("NeonLstmFloat32Workload", 1, 1); -} - -void NeonLstmFloat32Workload::Execute() const -{ - throw armnn::Exception("No implementation of Lstm in the Neon backend!"); -} - -} // namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.hpp deleted file mode 100644 index 78ee1da341..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ - -class NeonLstmFloat32Workload : public FloatWorkload -{ -public: - NeonLstmFloat32Workload(const LstmQueueDescriptor& descriptor, const WorkloadInfo& info); - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.cpp new file mode 100644 index 0000000000..8159e9feb4 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.cpp @@ -0,0 +1,22 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonLstmFloatWorkload.hpp" + +namespace armnn +{ +NeonLstmFloatWorkload::NeonLstmFloatWorkload(const LstmQueueDescriptor& descriptor, + const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonLstmFloatWorkload", 1, 1); +} + +void NeonLstmFloatWorkload::Execute() const +{ + throw armnn::Exception("No implementation of Lstm in the Neon backend!"); +} + +} // namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.hpp new file mode 100644 index 0000000000..fc06d55e6d --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.hpp @@ -0,0 +1,20 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ + +class NeonLstmFloatWorkload : public FloatWorkload +{ +public: + NeonLstmFloatWorkload(const LstmQueueDescriptor& descriptor, const WorkloadInfo& info); + virtual void Execute() const override; +}; + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.cpp deleted file mode 100644 index 30dd283620..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.cpp +++ /dev/null @@ -1,17 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonMergerFloat32Workload.hpp" - -namespace armnn -{ - -void NeonMergerFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMergerFloat32Workload_Execute"); - NeonBaseMergerWorkload::Execute(); -} - -} // namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.hpp deleted file mode 100644 index 7b8ee9881f..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include "NeonBaseMergerWorkload.hpp" - -namespace armnn -{ - -class NeonMergerFloat32Workload : public NeonBaseMergerWorkload -{ -public: - using NeonBaseMergerWorkload::NeonBaseMergerWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.cpp new file mode 100644 index 0000000000..02caca91bc --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.cpp @@ -0,0 +1,17 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonMergerFloatWorkload.hpp" + +namespace armnn +{ + +void NeonMergerFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMergerFloatWorkload_Execute"); + NeonBaseMergerWorkload::Execute(); +} + +} // namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.hpp new file mode 100644 index 0000000000..c9f8e66e38 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.hpp @@ -0,0 +1,20 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include "NeonBaseMergerWorkload.hpp" + +namespace armnn +{ + +class NeonMergerFloatWorkload : public NeonBaseMergerWorkload +{ +public: + using NeonBaseMergerWorkload::NeonBaseMergerWorkload; + virtual void Execute() const override; +}; + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.cpp deleted file mode 100644 index a8a3cd77b4..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.cpp +++ /dev/null @@ -1,60 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonMultiplicationFloat32Workload.hpp" - - -namespace armnn -{ - -arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output) -{ - const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0); - const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1); - const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); - - // 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. - return arm_compute::NEPixelWiseMultiplication::validate(&aclInput1, - &aclInput2, - &aclOutput, - 1.0f, - arm_compute::ConvertPolicy::SATURATE, - arm_compute::RoundingPolicy::TO_ZERO); -} - -NeonMultiplicationFloat32Workload::NeonMultiplicationFloat32Workload(const MultiplicationQueueDescriptor& descriptor, - const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - m_Data.ValidateInputsOutputs("NeonMultiplicationFloat32Workload", 2, 1); - - arm_compute::ITensor& input1 = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); - 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(); - - // 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); -} - -void NeonMultiplicationFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationFloat32Workload_Execute"); - m_PixelWiseMultiplication.run(); -} - -} //namespace armnn - - diff --git a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp deleted file mode 100644 index 62e84a2e07..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp +++ /dev/null @@ -1,30 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ -arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output); - -class NeonMultiplicationFloat32Workload : public FloatWorkload -{ -public: - NeonMultiplicationFloat32Workload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info); - virtual void Execute() const override; - -private: - mutable arm_compute::NEPixelWiseMultiplication m_PixelWiseMultiplication; -}; - -} //namespace armnn - - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.cpp new file mode 100644 index 0000000000..ca38a24b09 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.cpp @@ -0,0 +1,60 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonMultiplicationFloatWorkload.hpp" + + +namespace armnn +{ + +arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output) +{ + const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0); + const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1); + const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); + + // 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. + return arm_compute::NEPixelWiseMultiplication::validate(&aclInput1, + &aclInput2, + &aclOutput, + 1.0f, + arm_compute::ConvertPolicy::SATURATE, + arm_compute::RoundingPolicy::TO_ZERO); +} + +NeonMultiplicationFloatWorkload::NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor, + const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonMultiplicationFloatWorkload", 2, 1); + + arm_compute::ITensor& input1 = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); + 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(); + + // 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); +} + +void NeonMultiplicationFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationFloatWorkload_Execute"); + m_PixelWiseMultiplication.run(); +} + +} //namespace armnn + + diff --git a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp new file mode 100644 index 0000000000..eb0f7741f0 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp @@ -0,0 +1,30 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ +arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output); + +class NeonMultiplicationFloatWorkload : public FloatWorkload +{ +public: + NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info); + virtual void Execute() const override; + +private: + mutable arm_compute::NEPixelWiseMultiplication m_PixelWiseMultiplication; +}; + +} //namespace armnn + + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.cpp deleted file mode 100644 index 20936a2760..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.cpp +++ /dev/null @@ -1,70 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonNormalizationFloat32Workload.hpp" -#include "backends/NeonLayerSupport.hpp" -#include "backends/ArmComputeUtils.hpp" -#include "backends/ArmComputeTensorUtils.hpp" - -namespace armnn -{ - -arm_compute::Status NeonNormalizationWorkloadValidate(const TensorInfo& input, - const TensorInfo& output, - const NormalizationDescriptor& descriptor) -{ - const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input); - const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); - - arm_compute::NormalizationLayerInfo normalizationInfo = - armcomputetensorutils::BuildArmComputeNormalizationLayerInfo(descriptor); - - return arm_compute::NENormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo); -} - -NeonNormalizationFloat32Workload::NeonNormalizationFloat32Workload(const NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info, - std::shared_ptr& memoryManager) - : FloatWorkload(descriptor, info) - , m_NormalizationLayer(memoryManager) -{ - m_Data.ValidateInputsOutputs("NeonNormalizationFloat32Workload", 1, 1); - std::string reasonIfUnsupported; - if (!IsNeonNormalizationDescParamsSupported(&reasonIfUnsupported, m_Data.m_Parameters)) - { - throw UnimplementedException(reasonIfUnsupported); - } - - // Input and output tensors have to have the same dimensionality. - if (info.m_InputTensorInfos[0].GetShape()[1] != info.m_OutputTensorInfos[0].GetShape()[1] - || info.m_InputTensorInfos[0].GetShape()[0] != info.m_OutputTensorInfos[0].GetShape()[0] - || info.m_InputTensorInfos[0].GetShape()[3] != info.m_OutputTensorInfos[0].GetShape()[3] - || info.m_InputTensorInfos[0].GetShape()[2] != info.m_OutputTensorInfos[0].GetShape()[2]) - { - throw InvalidArgumentException("Normalization requires input and output tensors to have equal dimensionality."); - } - - 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(); - - const arm_compute::NormType normType = - ConvertNormalizationAlgorithmChannelToAclNormType(m_Data.m_Parameters.m_NormChannelType); - arm_compute::NormalizationLayerInfo normalizationInfo(normType, - m_Data.m_Parameters.m_NormSize, - m_Data.m_Parameters.m_Alpha, - m_Data.m_Parameters.m_Beta, - m_Data.m_Parameters.m_K, - false); - - m_NormalizationLayer.configure(&input, &output, normalizationInfo); -} - -void NeonNormalizationFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonNormalizationFloat32Workload_Execute"); - m_NormalizationLayer.run(); -} - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp deleted file mode 100644 index 8f0823454b..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp +++ /dev/null @@ -1,34 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -#include "arm_compute/runtime/MemoryManagerOnDemand.h" - -namespace armnn -{ - -arm_compute::Status NeonNormalizationWorkloadValidate(const TensorInfo& input, - const TensorInfo& output, - const NormalizationDescriptor& descriptor); - -class NeonNormalizationFloat32Workload : public FloatWorkload -{ -public: - NeonNormalizationFloat32Workload(const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info, - std::shared_ptr& memoryManager); - virtual void Execute() const override; - -private: - mutable arm_compute::NENormalizationLayer m_NormalizationLayer; -}; - -} //namespace armnn - - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.cpp new file mode 100644 index 0000000000..8c2a87d8bc --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.cpp @@ -0,0 +1,70 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonNormalizationFloatWorkload.hpp" +#include "backends/NeonLayerSupport.hpp" +#include "backends/ArmComputeUtils.hpp" +#include "backends/ArmComputeTensorUtils.hpp" + +namespace armnn +{ + +arm_compute::Status NeonNormalizationWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const NormalizationDescriptor& descriptor) +{ + const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input); + const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output); + + arm_compute::NormalizationLayerInfo normalizationInfo = + armcomputetensorutils::BuildArmComputeNormalizationLayerInfo(descriptor); + + return arm_compute::NENormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo); +} + +NeonNormalizationFloatWorkload::NeonNormalizationFloatWorkload(const NormalizationQueueDescriptor& descriptor, + const WorkloadInfo& info, + std::shared_ptr& memoryManager) + : FloatWorkload(descriptor, info) + , m_NormalizationLayer(memoryManager) +{ + m_Data.ValidateInputsOutputs("NeonNormalizationFloatWorkload", 1, 1); + std::string reasonIfUnsupported; + if (!IsNeonNormalizationDescParamsSupported(&reasonIfUnsupported, m_Data.m_Parameters)) + { + throw UnimplementedException(reasonIfUnsupported); + } + + // Input and output tensors have to have the same dimensionality. + if (info.m_InputTensorInfos[0].GetShape()[1] != info.m_OutputTensorInfos[0].GetShape()[1] + || info.m_InputTensorInfos[0].GetShape()[0] != info.m_OutputTensorInfos[0].GetShape()[0] + || info.m_InputTensorInfos[0].GetShape()[3] != info.m_OutputTensorInfos[0].GetShape()[3] + || info.m_InputTensorInfos[0].GetShape()[2] != info.m_OutputTensorInfos[0].GetShape()[2]) + { + throw InvalidArgumentException("Normalization requires input and output tensors to have equal dimensionality."); + } + + 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(); + + const arm_compute::NormType normType = + ConvertNormalizationAlgorithmChannelToAclNormType(m_Data.m_Parameters.m_NormChannelType); + arm_compute::NormalizationLayerInfo normalizationInfo(normType, + m_Data.m_Parameters.m_NormSize, + m_Data.m_Parameters.m_Alpha, + m_Data.m_Parameters.m_Beta, + m_Data.m_Parameters.m_K, + false); + + m_NormalizationLayer.configure(&input, &output, normalizationInfo); +} + +void NeonNormalizationFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonNormalizationFloatWorkload_Execute"); + m_NormalizationLayer.run(); +} + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp new file mode 100644 index 0000000000..8e8cc40c5a --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp @@ -0,0 +1,34 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +#include "arm_compute/runtime/MemoryManagerOnDemand.h" + +namespace armnn +{ + +arm_compute::Status NeonNormalizationWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const NormalizationDescriptor& descriptor); + +class NeonNormalizationFloatWorkload : public FloatWorkload +{ +public: + NeonNormalizationFloatWorkload(const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info, + std::shared_ptr& memoryManager); + virtual void Execute() const override; + +private: + mutable arm_compute::NENormalizationLayer m_NormalizationLayer; +}; + +} //namespace armnn + + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.cpp deleted file mode 100644 index cb690c51b8..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonPooling2dFloat32Workload.hpp" - - - -namespace armnn -{ - -NeonPooling2dFloat32Workload::NeonPooling2dFloat32Workload(const Pooling2dQueueDescriptor& descriptor, - const WorkloadInfo& info) - : NeonPooling2dBaseWorkload(descriptor, info, - "NeonPooling2dFloat32Workload") -{ -} - -void NeonPooling2dFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonPooling2dFloat32Workload_Execute"); - m_PoolingLayer.run(); -} - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp deleted file mode 100644 index 36c4e7edf1..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include -#include "NeonPooling2dBaseWorkload.hpp" - -namespace armnn -{ - -class NeonPooling2dFloat32Workload : public NeonPooling2dBaseWorkload -{ -public: - NeonPooling2dFloat32Workload(const Pooling2dQueueDescriptor& descriptor, const WorkloadInfo& info); - virtual void Execute() const override; -}; - -} //namespace armnn - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.cpp new file mode 100644 index 0000000000..90e09dbaf4 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.cpp @@ -0,0 +1,27 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonPooling2dFloatWorkload.hpp" + + + +namespace armnn +{ + +NeonPooling2dFloatWorkload::NeonPooling2dFloatWorkload(const Pooling2dQueueDescriptor& descriptor, + const WorkloadInfo& info) + : NeonPooling2dBaseWorkload(descriptor, info, + "NeonPooling2dFloatWorkload") +{ +} + +void NeonPooling2dFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonPooling2dFloatWorkload_Execute"); + m_PoolingLayer.run(); +} + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp new file mode 100644 index 0000000000..ba4e9cab6d --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp @@ -0,0 +1,25 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include +#include "NeonPooling2dBaseWorkload.hpp" + +namespace armnn +{ + +class NeonPooling2dFloatWorkload : public NeonPooling2dBaseWorkload +{ +public: + NeonPooling2dFloatWorkload(const Pooling2dQueueDescriptor& descriptor, const WorkloadInfo& info); + virtual void Execute() const override; +}; + +} //namespace armnn + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.cpp deleted file mode 100644 index 93f6eb8ef5..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.cpp +++ /dev/null @@ -1,32 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonReshapeFloat32Workload.hpp" - - - -namespace armnn -{ - -NeonReshapeFloat32Workload::NeonReshapeFloat32Workload(const ReshapeQueueDescriptor& descriptor, - const WorkloadInfo& info) - : FloatWorkload(descriptor, info) -{ - m_Data.ValidateInputsOutputs("NeonReshapeFloat32Workload", 1, 1); - - 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); -} - -void NeonReshapeFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonReshapeFloat32Workload_Execute"); - m_Layer.run(); -} - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp deleted file mode 100644 index 3e5cca1b9e..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -namespace armnn -{ - -class NeonReshapeFloat32Workload : public FloatWorkload -{ -public: - NeonReshapeFloat32Workload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info); - - virtual void Execute() const override; - -private: - mutable arm_compute::NEReshapeLayer m_Layer; -}; - -} //namespace armnn - - - - - diff --git a/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.cpp new file mode 100644 index 0000000000..ef229b252f --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.cpp @@ -0,0 +1,32 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonReshapeFloatWorkload.hpp" + + + +namespace armnn +{ + +NeonReshapeFloatWorkload::NeonReshapeFloatWorkload(const ReshapeQueueDescriptor& descriptor, + const WorkloadInfo& info) + : FloatWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonReshapeFloatWorkload", 1, 1); + + 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); +} + +void NeonReshapeFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonReshapeFloatWorkload_Execute"); + m_Layer.run(); +} + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp new file mode 100644 index 0000000000..d32d779962 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp @@ -0,0 +1,29 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +namespace armnn +{ + +class NeonReshapeFloatWorkload : public FloatWorkload +{ +public: + NeonReshapeFloatWorkload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info); + + virtual void Execute() const override; + +private: + mutable arm_compute::NEReshapeLayer m_Layer; +}; + +} //namespace armnn + + + + + diff --git a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.cpp deleted file mode 100644 index 027b508ad5..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.cpp +++ /dev/null @@ -1,32 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonSoftmaxFloat32Workload.hpp" - -namespace armnn -{ - -NeonSoftmaxFloat32Workload::NeonSoftmaxFloat32Workload(const SoftmaxQueueDescriptor& descriptor, - const WorkloadInfo& info, std::shared_ptr& memoryManager) - : FloatWorkload(descriptor, info) - , m_SoftmaxLayer(memoryManager) -{ - m_Data.ValidateInputsOutputs("NeonSoftmaxFloat32Workload", 1, 1); - - // The ArmCompute softmax layer uses 2D input/output tensors, so flatten the first three dimensions. - 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); -} - -void NeonSoftmaxFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSoftmaxFloat32Workload_Execute"); - m_SoftmaxLayer.run(); -} - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp deleted file mode 100644 index 3656a26a3c..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include - -#include "arm_compute/runtime/MemoryManagerOnDemand.h" - -#include - -namespace armnn -{ - -class NeonSoftmaxFloat32Workload : public FloatWorkload -{ -public: - NeonSoftmaxFloat32Workload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info, - std::shared_ptr& memoryManager); - virtual void Execute() const override; - -private: - mutable arm_compute::NESoftmaxLayer m_SoftmaxLayer; -}; - -} //namespace armnn - diff --git a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.cpp new file mode 100644 index 0000000000..981e63ea55 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.cpp @@ -0,0 +1,32 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonSoftmaxFloatWorkload.hpp" + +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); + + // The ArmCompute softmax layer uses 2D input/output tensors, so flatten the first three dimensions. + 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); +} + +void NeonSoftmaxFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSoftmaxFloatWorkload_Execute"); + m_SoftmaxLayer.run(); +} + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp new file mode 100644 index 0000000000..52dbded5dd --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp @@ -0,0 +1,29 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +#include "arm_compute/runtime/MemoryManagerOnDemand.h" + +#include + +namespace armnn +{ + +class NeonSoftmaxFloatWorkload : public FloatWorkload +{ +public: + NeonSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info, + std::shared_ptr& memoryManager); + virtual void Execute() const override; + +private: + mutable arm_compute::NESoftmaxLayer m_SoftmaxLayer; +}; + +} //namespace armnn + diff --git a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.cpp deleted file mode 100644 index 996fc15adb..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.cpp +++ /dev/null @@ -1,17 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#include "NeonSplitterFloat32Workload.hpp" - -namespace armnn -{ - -void NeonSplitterFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSplitterFloat32Workload_Execute"); - NeonBaseSplitterWorkload::Execute(); -} - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp deleted file mode 100644 index 9f6dc75499..0000000000 --- a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// See LICENSE file in the project root for full license information. -// - -#pragma once - -#include "NeonBaseSplitterWorkload.hpp" - -namespace armnn -{ - -class NeonSplitterFloat32Workload : public NeonBaseSplitterWorkload -{ -public: - using NeonBaseSplitterWorkload::NeonBaseSplitterWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.cpp new file mode 100644 index 0000000000..06e300cd5a --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.cpp @@ -0,0 +1,17 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "NeonSplitterFloatWorkload.hpp" + +namespace armnn +{ + +void NeonSplitterFloatWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSplitterFloatWorkload_Execute"); + NeonBaseSplitterWorkload::Execute(); +} + +} //namespace armnn diff --git a/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp new file mode 100644 index 0000000000..5d6b328413 --- /dev/null +++ b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp @@ -0,0 +1,20 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include "NeonBaseSplitterWorkload.hpp" + +namespace armnn +{ + +class NeonSplitterFloatWorkload : public NeonBaseSplitterWorkload +{ +public: + using NeonBaseSplitterWorkload::NeonBaseSplitterWorkload; + virtual void Execute() const override; +}; + +} //namespace armnn -- cgit v1.2.1