diff options
Diffstat (limited to 'src/backends/reference')
191 files changed, 0 insertions, 18363 deletions
diff --git a/src/backends/reference/CMakeLists.txt b/src/backends/reference/CMakeLists.txt deleted file mode 100644 index 0dbaa339c5..0000000000 --- a/src/backends/reference/CMakeLists.txt +++ /dev/null @@ -1,42 +0,0 @@ -# -# Copyright © 2017 Arm Ltd. All rights reserved. -# SPDX-License-Identifier: MIT -# - -if(ARMNNREF) - list(APPEND armnnRefBackend_sources - RefBackend.cpp - RefBackend.hpp - RefBackendId.hpp - RefTensorHandle.hpp - RefTensorHandle.cpp - RefLayerSupport.cpp - RefLayerSupport.hpp - RefMemoryManager.hpp - RefMemoryManager.cpp - RefRegistryInitializer.cpp - RefWorkloadFactory.cpp - RefWorkloadFactory.hpp - RefTensorHandleFactory.cpp - RefTensorHandleFactory.hpp - ) - - add_subdirectory(workloads) - - if(BUILD_UNIT_TESTS) - add_subdirectory(test) - endif() - -else() - list(APPEND armnnRefBackend_sources - RefBackendId.hpp - RefLayerSupport.cpp - RefLayerSupport.hpp - ) -endif() - -add_library(armnnRefBackend OBJECT ${armnnRefBackend_sources}) -target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn) -target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils) -target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends) -target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/profiling) diff --git a/src/backends/reference/RefBackend.cpp b/src/backends/reference/RefBackend.cpp deleted file mode 100644 index 584ce78fdb..0000000000 --- a/src/backends/reference/RefBackend.cpp +++ /dev/null @@ -1,95 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefBackend.hpp" -#include "RefBackendId.hpp" -#include "RefWorkloadFactory.hpp" -#include "RefLayerSupport.hpp" -#include "RefTensorHandleFactory.hpp" - -#include <armnn/BackendRegistry.hpp> - -#include <armnn/backends/IBackendContext.hpp> -#include <armnn/backends/IMemoryManager.hpp> - -#include <Optimizer.hpp> - -#include <boost/polymorphic_pointer_cast.hpp> - -namespace armnn -{ - -const BackendId& RefBackend::GetIdStatic() -{ - static const BackendId s_Id{RefBackendId()}; - return s_Id; -} - -IBackendInternal::IWorkloadFactoryPtr RefBackend::CreateWorkloadFactory( - const IBackendInternal::IMemoryManagerSharedPtr& memoryManager) const -{ - return std::make_unique<RefWorkloadFactory>(boost::polymorphic_pointer_downcast<RefMemoryManager>(memoryManager)); -} - -IBackendInternal::IWorkloadFactoryPtr RefBackend::CreateWorkloadFactory( - class TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const -{ - auto memoryManager = std::make_shared<RefMemoryManager>(); - - tensorHandleFactoryRegistry.RegisterMemoryManager(memoryManager); - - return std::make_unique<RefWorkloadFactory>(boost::polymorphic_pointer_downcast<RefMemoryManager>(memoryManager)); -} - -IBackendInternal::IBackendContextPtr RefBackend::CreateBackendContext(const IRuntime::CreationOptions&) const -{ - return IBackendContextPtr{}; -} - -IBackendInternal::IBackendProfilingContextPtr RefBackend::CreateBackendProfilingContext( - const IRuntime::CreationOptions&, IBackendProfilingPtr&) -{ - return IBackendProfilingContextPtr{}; -} - -IBackendInternal::IMemoryManagerUniquePtr RefBackend::CreateMemoryManager() const -{ - return std::make_unique<RefMemoryManager>(); -} - -IBackendInternal::Optimizations RefBackend::GetOptimizations() const -{ - return Optimizations{}; -} - -IBackendInternal::ILayerSupportSharedPtr RefBackend::GetLayerSupport() const -{ - static ILayerSupportSharedPtr layerSupport{new RefLayerSupport}; - return layerSupport; -} - -OptimizationViews RefBackend::OptimizeSubgraphView(const SubgraphView& subgraph) const -{ - OptimizationViews optimizationViews; - - optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph)); - - return optimizationViews; -} - -std::vector<ITensorHandleFactory::FactoryId> RefBackend::GetHandleFactoryPreferences() const -{ - return std::vector<ITensorHandleFactory::FactoryId> { RefTensorHandleFactory::GetIdStatic() }; -} - -void RefBackend::RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry) -{ - auto memoryManager = std::make_shared<RefMemoryManager>(); - - registry.RegisterMemoryManager(memoryManager); - registry.RegisterFactory(std::make_unique<RefTensorHandleFactory>(memoryManager)); -} - -} // namespace armnn diff --git a/src/backends/reference/RefBackend.hpp b/src/backends/reference/RefBackend.hpp deleted file mode 100644 index 92d392dde6..0000000000 --- a/src/backends/reference/RefBackend.hpp +++ /dev/null @@ -1,44 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <armnn/backends/IBackendInternal.hpp> - -namespace armnn -{ - -class RefBackend : public IBackendInternal -{ -public: - RefBackend() = default; - ~RefBackend() = default; - - static const BackendId& GetIdStatic(); - const BackendId& GetId() const override { return GetIdStatic(); } - - IBackendInternal::IMemoryManagerUniquePtr CreateMemoryManager() const override; - - IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory( - const IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr) const override; - - IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory( - class TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const override; - - IBackendInternal::IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const override; - - IBackendInternal::IBackendProfilingContextPtr CreateBackendProfilingContext( - const IRuntime::CreationOptions& creationOptions, IBackendProfilingPtr& backendProfiling) override; - - IBackendInternal::Optimizations GetOptimizations() const override; - IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override; - - OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph) const override; - - std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences() const override; - - void RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry) override; -}; - -} // namespace armnn diff --git a/src/backends/reference/RefBackendId.hpp b/src/backends/reference/RefBackendId.hpp deleted file mode 100644 index 2a7f9f19d9..0000000000 --- a/src/backends/reference/RefBackendId.hpp +++ /dev/null @@ -1,12 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -namespace armnn -{ - -constexpr const char * RefBackendId() { return "CpuRef"; } - -} // namespace armnn diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp deleted file mode 100644 index 5cb36c4299..0000000000 --- a/src/backends/reference/RefLayerSupport.cpp +++ /dev/null @@ -1,1914 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefLayerSupport.hpp" - -#include <armnn/TypesUtils.hpp> -#include <armnn/Types.hpp> -#include <armnn/Descriptors.hpp> - -#include <LayerSupportCommon.hpp> - -#include <backendsCommon/LayerSupportRules.hpp> - -#include <boost/cast.hpp> -#include <boost/core/ignore_unused.hpp> - -#include <vector> -#include <array> - -using namespace boost; - -namespace armnn -{ - -namespace -{ - -template<typename Float32Func, typename Uint8Func, typename ... Params> -bool IsSupportedForDataTypeRef(Optional<std::string&> reasonIfUnsupported, - DataType dataType, - Float32Func floatFuncPtr, - Uint8Func uint8FuncPtr, - Params&&... params) -{ - return IsSupportedForDataTypeGeneric(reasonIfUnsupported, - dataType, - &FalseFunc<Params...>, - floatFuncPtr, - uint8FuncPtr, - &FalseFunc<Params...>, - &FalseFunc<Params...>, - std::forward<Params>(params)...); -} - -} // anonymous namespace - -namespace -{ - -std::string CreateIncorrectDimensionsErrorMsg(unsigned int expected, - unsigned int actual, - std::string& layerStr, - std::string& tensorName) -{ - std::string errorMsg = "Reference " + layerStr + ": Expected " + std::to_string(expected) + " dimensions but got" + - " " + std::to_string(actual) + " dimensions instead, for the '" + tensorName + "' tensor."; - - return errorMsg; -} - -} // anonymous namespace - -bool RefLayerSupport::IsAbsSupported(const TensorInfo& input, const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - return IsElementwiseUnarySupported(input, - output, - ElementwiseUnaryDescriptor(UnaryOperation::Abs), - reasonIfUnsupported); -} - -bool RefLayerSupport::IsActivationSupported(const TensorInfo& input, - const TensorInfo& output, - const ActivationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - // Define supported types. - std::array<DataType,6> supportedTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference activation: input type not supported."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference activation: output type not supported."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference activation: input and output types mismatched."); - - supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported, - "Reference activation: input and output shapes are of different rank."); - - - struct ActivationFunctionSupported : public Rule - { - ActivationFunctionSupported(const ActivationDescriptor& desc) - { - switch(desc.m_Function) - { - case ActivationFunction::Abs: - case ActivationFunction::BoundedReLu: - case ActivationFunction::LeakyReLu: - case ActivationFunction::Linear: - case ActivationFunction::ReLu: - case ActivationFunction::Sigmoid: - case ActivationFunction::SoftReLu: - case ActivationFunction::Sqrt: - case ActivationFunction::Square: - case ActivationFunction::TanH: - { - m_Res = true; - break; - } - default: - { - m_Res = false; - break; - } - } - } - }; - - // Function is supported - supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported, - "Reference activation: function not supported."); - - return supported; -} - -bool RefLayerSupport::IsAdditionSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,6> supportedTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported, - "Reference addition: input 0 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported, - "Reference addition: input 1 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference addition: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported, - "Reference addition: input 0 and Input 1 types are mismatched"); - - supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported, - "Reference addition: input and output types are mismatched"); - - supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported, - "Reference addition: shapes are not suitable for implicit broadcast."); - - return supported; -} - -bool RefLayerSupport::IsArgMinMaxSupported(const armnn::TensorInfo &input, const armnn::TensorInfo &output, - const armnn::ArgMinMaxDescriptor &descriptor, - armnn::Optional<std::string &> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - - std::array<DataType, 4> supportedTypes = - { - DataType::Float32, - DataType::QAsymmU8, - DataType::QSymmS16, - DataType::Signed32 - }; - - bool supported = true; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference ArgMinMax: input is not a supported type."); - supported &= CheckSupportRule(TypeIs(output, DataType::Signed32), reasonIfUnsupported, - "Reference ArgMinMax: output type not supported"); - - return supported; -} - -bool RefLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& mean, - const TensorInfo& variance, - const TensorInfo& beta, - const TensorInfo& gamma, - const BatchNormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - - std::array<DataType, 4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - bool supported = true; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference batch normalization: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference batch normalization: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference batch normalization: input and output types are mismatched"); - - supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported, - "Reference batch normalization: mean is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported, - "Reference batch normalization: variance is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported, - "Reference batch normalization: beta is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported, - "Reference batch normalization: gamma is not a supported type."); - - return supported; -} - -bool RefLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input, - const TensorInfo& output, - const BatchToSpaceNdDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - - bool supported = true; - - std::string batchToSpaceNdLayerStr = "batchToSpaceNd"; - std::string inputTensorStr = "input"; - std::string outputTensorStr = "output"; - - // Define supported types. - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference BatchToSpaceNd: input type not supported."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference BatchToSpaceNd: output type not supported."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference BatchToSpaceNd: input and output types mismatched."); - - supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4), - reasonIfUnsupported, - CreateIncorrectDimensionsErrorMsg(4, - output.GetNumDimensions(), - batchToSpaceNdLayerStr, - outputTensorStr).data()); - - supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4), - reasonIfUnsupported, - CreateIncorrectDimensionsErrorMsg(4, - input.GetNumDimensions(), - batchToSpaceNdLayerStr, - inputTensorStr).data()); - - return supported; -} - -bool RefLayerSupport::IsComparisonSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - const ComparisonDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(descriptor); - - std::array<DataType, 4> supportedInputTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - bool supported = true; - supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported, - "Reference comparison: input 0 is not a supported type"); - - supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported, - "Reference comparison: input 0 and Input 1 types are mismatched"); - - supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported, - "Reference comparison: output is not of type Boolean"); - - return supported; -} - -bool RefLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs, - const TensorInfo& output, - const ConcatDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - - bool supported = true; - std::array<DataType,5> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QAsymmS8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference concatenation: output type not supported"); - for (const TensorInfo* input : inputs) - { - BOOST_ASSERT(input != nullptr); - supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported, - "Reference concatenation: input type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported, - "Reference concatenation: input and output types mismatched."); - } - - return supported; -} - -bool RefLayerSupport::IsConstantSupported(const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - std::array<DataType,6> supportedTypes = - { - DataType::Float32, - DataType::Signed32, - DataType::QAsymmU8, - DataType::QAsymmS8, - DataType::QSymmS8, - DataType::QSymmS16 - }; - - return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference constant: output is not a supported type."); -} - -bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - return (IsSupportedForDataTypeGeneric(reasonIfUnsupported, - input.GetDataType(), - &TrueFunc<>, - &FalseInputFuncF32<>, - &FalseFuncU8<>, - &FalseFuncI32<>, - &FalseFuncU8<>) && - IsSupportedForDataTypeGeneric(reasonIfUnsupported, - output.GetDataType(), - &FalseOutputFuncF16<>, - &TrueFunc<>, - &FalseFuncU8<>, - &FalseFuncI32<>, - &FalseFuncU8<>)); -} - -bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - return (IsSupportedForDataTypeGeneric(reasonIfUnsupported, - input.GetDataType(), - &FalseInputFuncF16<>, - &TrueFunc<>, - &FalseFuncU8<>, - &FalseFuncI32<>, - &FalseFuncU8<>) && - IsSupportedForDataTypeGeneric(reasonIfUnsupported, - output.GetDataType(), - &TrueFunc<>, - &FalseOutputFuncF32<>, - &FalseFuncU8<>, - &FalseFuncI32<>, - &FalseFuncU8<>)); -} - -bool RefLayerSupport::IsConvolution2dSupported(const TensorInfo& input, - const TensorInfo& output, - const Convolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - // Define supported types. - std::array<DataType,6> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QAsymmS8, - DataType::QSymmS8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Convolution2d: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Convolution2d: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Convolution2d: input and output types mismatched."); - - const DataType inputType = input.GetDataType(); - if (IsQuantized8BitType(inputType)) - { - ARMNN_NO_DEPRECATE_WARN_BEGIN - std::array<DataType, 4> supportedWeightTypes = - { - DataType::QAsymmU8, - DataType::QSymmS8, - DataType::QAsymmS8, - DataType::QuantizedSymm8PerAxis // deprecated - }; - ARMNN_NO_DEPRECATE_WARN_END - - supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported, - "Reference Convolution2d: weights type not supported for quantized input."); - } - else - { - supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported, - "Reference Convolution2d: weights is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported, - "Reference Convolution2d: input and weights types mismatched."); - } - - if (biases.has_value()) - { - std::array<DataType,3> biasesSupportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::Signed32 - }; - - supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported, - "Reference Convolution2d: biases is not a supported type."); - } - ignore_unused(descriptor); - - return supported; -} - -bool RefLayerSupport::IsDebugSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType, 7> supportedTypes = - { - DataType::Float16, - DataType::Float32, - DataType::QAsymmU8, - DataType::QAsymmS8, - DataType::QSymmS8, - DataType::QSymmS16, - DataType::Signed32 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference for Debug layer: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference for Debug layer: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference for Debug layer: input and output types are mismatched"); - - return supported; -} - -bool RefLayerSupport::IsDepthToSpaceSupported(const TensorInfo& input, - const TensorInfo& output, - const DepthToSpaceDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference DepthToSpace: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference DepthToSpace: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference DepthToSpace: input and output types are mismatched"); - - return supported; -} - -bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input, - const TensorInfo& output, - const DepthwiseConvolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - // Define supported types. - std::array<DataType,6> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QSymmS8, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference DepthwiseConvolution2d: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference DepthwiseConvolution2d: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference DepthwiseConvolution2d: input and output types mismatched."); - - ARMNN_NO_DEPRECATE_WARN_BEGIN - std::array<DataType, 3> supportedWeightTypes = - { - DataType::QAsymmU8, - DataType::QSymmS8, - DataType::QuantizedSymm8PerAxis // deprecated - }; - ARMNN_NO_DEPRECATE_WARN_END - - const DataType inputType = input.GetDataType(); - if (IsQuantized8BitType(inputType)) - { - - supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported, - "Reference convolution2d: weights type not supported for quantized input."); - } - else - { - supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported, - "Reference DepthwiseConvolution2d: weights is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported, - "Reference DepthwiseConvolution2d: input and weights types mismatched."); - } - - if (biases.has_value()) - { - std::array<DataType,3> biasesSupportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::Signed32 - }; - supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported, - "Reference DepthwiseConvolution2d: biases is not a supported type."); - } - ignore_unused(descriptor); - - return supported; - -} - -bool RefLayerSupport::IsDequantizeSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,4> supportedInputTypes = { - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported, - "Reference for Dequantize layer: input type not supported."); - - supported &= CheckSupportRule( TypeNotPerAxisQuantized(input), reasonIfUnsupported, - "Reference for Dequantize layer: per-axis quantized input not support ."); - - supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported, - "Reference dequantize: per-axis quantized input not support ."); - - std::array<DataType,2> supportedOutputTypes = { - DataType::Float32, - DataType::Float16 - }; - - supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported, - "Reference for Dequantize layer: output type not supported."); - - supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported, - "Reference for Dequantize layer: input/output shapes have different num total " - "elements."); - - return supported; -} - -bool RefLayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings, - const TensorInfo& scores, - const TensorInfo& anchors, - const TensorInfo& detectionBoxes, - const TensorInfo& detectionClasses, - const TensorInfo& detectionScores, - const TensorInfo& numDetections, - const DetectionPostProcessDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor); - - bool supported = true; - - std::array<DataType,3> supportedInputTypes = - { - DataType::Float32, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported, - "Reference DetectionPostProcess: input 0 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported, - "Reference DetectionPostProcess: input 1 is not a supported type."); - - return supported; -} - -bool RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input, - const TensorInfo& output, - const DepthwiseConvolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported) const -{ - return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported); -} - -bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,4> supportedTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported, - "Reference division: input 0 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported, - "Reference division: input 1 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference division: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported, - "Reference division: input 0 and Input 1 types are mismatched"); - - supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported, - "Reference division: input and output types are mismatched"); - - supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported, - "Reference division: shapes are not suitable for implicit broadcast."); - - return supported; -} - -bool RefLayerSupport::IsElementwiseUnarySupported(const TensorInfo& input, - const TensorInfo& output, - const ElementwiseUnaryDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(descriptor); - - std::array<DataType, 4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - bool supported = true; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference elementwise unary: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference elementwise unary: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference elementwise unary: input and output types not matching"); - - supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported, - "Reference elementwise unary: input and output shapes" - "have different number of total elements"); - - return supported; -} - -bool RefLayerSupport::IsEqualSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - return IsComparisonSupported(input0, - input1, - output, - ComparisonDescriptor(ComparisonOperation::Equal), - reasonIfUnsupported); -} - -bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input, - const FakeQuantizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - - std::array<DataType,1> supportedTypes = - { - DataType::Float32 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference fake quantization: input type not supported."); - - return supported; -} - -bool RefLayerSupport::IsFloorSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(output); - bool supported = true; - - std::array<DataType,3> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Floor: input type not supported."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Floor: output type not supported."); - - return supported; -} - -bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& weights, - const TensorInfo& biases, - const FullyConnectedDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - // Define supported types. - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Fully Connected: input type not supported."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Fully Connected: output type not supported."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Fully Connected: input and output types mismatched."); - - supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported, - "Reference Fully Connected: weights type not supported."); - - supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported, - "Reference Fully Connected: input and weight types mismatched."); - - if (descriptor.m_BiasEnabled) - { - // Defined supported types for bias - std::array<DataType, 3> - supportedBiasTypes = - { - DataType::Float32, - DataType::Float16, - DataType::Signed32 - }; - - supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported, - "Reference Fully Connected: bias type not supported."); - - supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported, - "Reference Fully Connected: bias and weight types mismatch."); - - supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported, - "Reference Fully Connected: bias type inferred from weights is incompatible."); - - } - - return supported; -} - -bool RefLayerSupport::IsGatherSupported(const armnn::TensorInfo& input0, - const armnn::TensorInfo& input1, - const armnn::TensorInfo& output, - armnn::Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported, - "Reference Gather: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Gather: output type not supported"); - - supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported, - "Reference Gather: indices (input1) type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported, - "Reference Gather: input and output types not matching"); - - return supported; -} - -bool RefLayerSupport::IsGreaterSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - return IsComparisonSupported(input0, - input1, - output, - ComparisonDescriptor(ComparisonOperation::Greater), - reasonIfUnsupported); -} - -bool RefLayerSupport::IsInputSupported(const TensorInfo& /*input*/, - Optional<std::string&> /*reasonIfUnsupported*/) const -{ - return true; -} - -bool RefLayerSupport::IsInstanceNormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const InstanceNormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - // Define supported types - std::array<DataType, 4> supportedTypes = - { - DataType::Float32, - DataType::Float16 - }; - - bool supported = true; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Instance Normalization: input type not supported."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Instance Normalization: output type not supported."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Instance Normalization: input and output types mismatched."); - - supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported, - "Reference Instance Normalization: input and output shapes have different " - "num total elements."); - - return supported; -} - -bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const L2NormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - // Define supported types - std::array<DataType, 4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - bool supported = true; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference L2normalization: input type not supported."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference L2normalization: output type not supported."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference L2normalization: input and output types mismatched."); - - supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported, - "Reference L2normalization: input and output shapes have different " - "num total elements."); - - return supported; -} - -bool RefLayerSupport::IsLogSoftmaxSupported(const TensorInfo& input, - const TensorInfo& output, - const LogSoftmaxDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - - std::array<DataType, 2> supportedTypes = - { - DataType::Float32, - DataType::Float16 - }; - - bool supported = true; - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference LogSoftmax: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference LogSoftmax: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference LogSoftmax: input and output types do not match"); - - return supported; -} - -bool RefLayerSupport::IsLstmSupported(const TensorInfo& input, - const TensorInfo& outputStateIn, - const TensorInfo& cellStateIn, - const TensorInfo& scratchBuffer, - const TensorInfo& outputStateOut, - const TensorInfo& cellStateOut, - const TensorInfo& output, - const LstmDescriptor& descriptor, - const LstmInputParamsInfo& paramsInfo, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - ignore_unused(paramsInfo); - - bool supported = true; - - std::array<DataType,2> supportedTypes = { - DataType::Float32, - DataType::QSymmS16 - }; - - // check inputs and outputs - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Lstm: input is not a supported type."); - supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported, - "Reference Lstm: input and outputStateIn types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported, - "Reference Lstm: input and cellStateIn types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported, - "Reference Lstm: input and scratchBuffer types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported, - "Reference Lstm: input and outputStateOut types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported, - "Reference Lstm: input and cellStateOut types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Lstm: input and output types are mismatched"); - // check layer parameters - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported, - "Reference Lstm: input and InputToForgetWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported, - "Reference Lstm: input and InputToCellWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported, - "Reference Lstm: input and InputToOutputWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported, - "Reference Lstm: input and RecurrentToForgetWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported, - "Reference Lstm: input and RecurrentToCellWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported, - "Reference Lstm: input and RecurrentToOutputWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported, - "Reference Lstm: input and ForgetGateBias types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported, - "Reference Lstm: input and CellBias types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported, - "Reference Lstm: input and OutputGateBias types are mismatched"); - if (!descriptor.m_CifgEnabled) - { - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported, - "Reference Lstm: input and InputToInputWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()), - reasonIfUnsupported, - "Reference Lstm: input and RecurrentToInputWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported, - "Reference Lstm: input and InputGateBias types are mismatched"); - if (descriptor.m_PeepholeEnabled) - { - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()), - reasonIfUnsupported, - "Reference Lstm: input and CellToInputWeights types are mismatched"); - } - } - if (descriptor.m_PeepholeEnabled) - { - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported, - "Reference Lstm: input and CellToForgetWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported, - "Reference Lstm: input and CellToOutputWeights types are mismatched"); - } - if (descriptor.m_ProjectionEnabled) - { - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported, - "Reference Lstm: input and mProjectionWeights types are mismatched"); - if (paramsInfo.m_ProjectionBias != nullptr) - { - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported, - "Reference Lstm: input and ProjectionBias types are mismatched"); - } - } - if (descriptor.m_LayerNormEnabled) - { - if (!descriptor.m_CifgEnabled) - { - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()), - reasonIfUnsupported, - "Reference Lstm: input and InputLayerNormWeights types are mismatched"); - } - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()), - reasonIfUnsupported, - "Reference Lstm: input and ForgetLayerNormWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()), - reasonIfUnsupported, - "Reference Lstm: input and CellLayerNormWeights types are mismatched"); - supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()), - reasonIfUnsupported, - "Reference Lstm: input and OutputLayerNormWeights types are mismatched"); - } - - return supported; -} - -bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,5> supportedTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported, - "Reference maximum: input 0 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported, - "Reference maximum: input 1 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference maximum: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported, - "Reference maximum: input 0 and Input 1 types are mismatched"); - - supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported, - "Reference maximum: input and output types are mismatched"); - - supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported, - "Reference maximum: shapes are not suitable for implicit broadcast."); - - return supported; -} - -bool RefLayerSupport::IsMeanSupported(const TensorInfo& input, - const TensorInfo& output, - const MeanDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - std::string meanLayerStr = "Mean"; - std::string outputTensorStr = "output"; - - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Mean: input type not supported."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Mean: input and output types are mismatched"); - - if (descriptor.m_KeepDims) - { - supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()), - reasonIfUnsupported, - CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(), - output.GetNumDimensions(), - meanLayerStr, outputTensorStr).data()); - } - else if (descriptor.m_Axis.empty()) - { - supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1), - reasonIfUnsupported, - CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(), - meanLayerStr, outputTensorStr).data()); - } - else - { - auto outputDim = input.GetNumDimensions() - boost::numeric_cast<unsigned int>(descriptor.m_Axis.size()); - - if (outputDim > 0) - { - supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim), - reasonIfUnsupported, - CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(), - meanLayerStr, outputTensorStr).data()); - } - else - { - supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1), - reasonIfUnsupported, - CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(), - meanLayerStr, outputTensorStr).data()); - } - } - - return supported; -} - -bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs, - const TensorInfo& output, - const MergerDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported); -} - -bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input, - const TensorInfo &output, - Optional<std::string &> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,5> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16, - DataType::Boolean - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference MemCopy: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference MemCopy: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference MemCopy: input and output types are mismatched"); - - return supported; -} - -bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,4> supportedTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported, - "Reference minimum: input 0 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported, - "Reference minimum: input 1 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference minimum: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported, - "Reference minimum: input 0 and Input 1 types are mismatched"); - - supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported, - "Reference minimum: input and output types are mismatched"); - - supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported, - "Reference minimum: shapes are not suitable for implicit broadcast."); - - return supported; -} - -bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,6> supportedTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QAsymmS8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported, - "Reference multiplication: input 0 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported, - "Reference multiplication: input 1 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference multiplication: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported, - "Reference multiplication: input 0 and Input 1 types are mismatched"); - - supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported, - "Reference multiplication: input and output types are mismatched"); - - supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported, - "Reference multiplication: shapes are not suitable for implicit broadcast."); - - return supported; -} - -bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const NormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - - // Define supported types - std::array<DataType, 4> supportedTypes = - { - DataType::Float16, - DataType::Float32, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - bool supported = true; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference normalization: input type not supported."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference normalization: output type not supported."); - - supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported, - "Reference normalization: input and output shapes have different " - "num total elements."); - - return supported; -} - -bool RefLayerSupport::IsOutputSupported(const TensorInfo& /*output*/, - Optional<std::string&> /*reasonIfUnsupported*/) const -{ - return true; -} - -bool RefLayerSupport::IsPadSupported(const TensorInfo& input, - const TensorInfo& output, - const PadDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - - // Define supported output and inputs types. - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference pad: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference pad: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference pad: input and output types are mismatched."); - - return supported; -} - -bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input, - const TensorInfo& output, - const PermuteDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - - // Define supported output and inputs types. - std::array<DataType,3> supportedTypes = - { - DataType::Float32, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference permute: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference permute: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference permute: input and output types are mismatched."); - - return supported; -} - -bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input, - const TensorInfo& output, - const Pooling2dDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - - // Define supported output and inputs types. - std::array<DataType,5> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference poolind2d: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference poolind2d: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference poolind2d: input and output types are mismatched."); - - return supported; -} - -bool RefLayerSupport::IsQuantizeSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - // Define supported input types. - std::array<DataType,6> supportedInputTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported, - "Reference quantize: input type not supported."); - - // Define supported output types. - std::array<DataType,4> supportedOutputTypes = { - DataType::QAsymmU8, - DataType::QAsymmS8, - DataType::QSymmS8, - DataType::QSymmS16 - }; - supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported, - "Reference quantize: output type not supported."); - - supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported, - "Reference quantize: input and output shapes have different num total elements."); - - return supported; -} - -bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input, - const TensorInfo& output, - const ReshapeDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(output); - ignore_unused(descriptor); - // Define supported output types. - std::array<DataType,7> supportedOutputTypes = - { - DataType::Float32, - DataType::Float16, - DataType::Signed32, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported, - "Reference reshape: input type not supported."); -} - -bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference ResizeBilinear: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference ResizeBilinear: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference ResizeBilinear: input and output types not matching"); - - return supported; -} - -bool RefLayerSupport::IsResizeSupported(const TensorInfo& input, - const TensorInfo& output, - const ResizeDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(descriptor); - bool supported = true; - std::array<DataType,5> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QAsymmS8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Resize: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Resize: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Resize: input and output types not matching"); - - return supported; -} - -bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - return IsElementwiseUnarySupported(input, - output, - ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt), - reasonIfUnsupported); -} - -bool RefLayerSupport::IsSliceSupported(const TensorInfo& input, - const TensorInfo& output, - const SliceDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(descriptor); - bool supported = true; - - std::array<DataType, 3> supportedTypes = - { - DataType::Float32, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Slice: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Slice: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Slice: input and output types are mismatched"); - - return supported; -} - -bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input, - const TensorInfo& output, - const SoftmaxDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(descriptor); - bool supported = true; - std::array<DataType,6> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QSymmS8, - DataType::QAsymmS8, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference Softmax: output type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference Softmax: input type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference Softmax: input type not supported"); - - return supported; -} - -bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input, - const TensorInfo& output, - const SpaceToBatchNdDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(descriptor); - bool supported = true; - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference SpaceToBatchNd: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference SpaceToBatchNd: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference SpaceToBatchNd: input and output types are mismatched"); - - return supported; -} - -bool RefLayerSupport::IsSpaceToDepthSupported(const TensorInfo& input, - const TensorInfo& output, - const SpaceToDepthDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - - ignore_unused(descriptor); - bool supported = true; - - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference SpaceToDepth: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference SpaceToDepth: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference SpaceToDepth: input and output types are mismatched"); - - return supported; -} - -bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input, - const ViewsDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference splitter: input type not supported"); - - return supported; -} - -bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input, - const std::vector<std::reference_wrapper<TensorInfo>>& outputs, - const ViewsDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference splitter: output type not supported"); - for (const TensorInfo output : outputs) - { - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference splitter: input type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference splitter: input and output types mismatched."); - } - - return supported; -} - -bool RefLayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs, - const TensorInfo& output, - const StackDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - - bool supported = true; - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference stack: output type not supported"); - for (const TensorInfo* input : inputs) - { - BOOST_ASSERT(input != nullptr); - supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported, - "Reference stack: input type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported, - "Reference stack: input and output types mismatched."); - } - - return supported; -} - -bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input, - const TensorInfo& output, - const StridedSliceDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const -{ - ignore_unused(descriptor); - bool supported = true; - - std::array<DataType,3> supportedTypes = - { - DataType::Float32, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference StridedSlice: input type not supported"); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference StridedSlice: output type not supported"); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference StridedSlice: input and output types are mismatched"); - - return supported; -} - -bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType,4> supportedTypes = { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported, - "Reference subtraction: input 0 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported, - "Reference subtraction: input 1 is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference subtraction: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported, - "Reference subtraction: input 0 and Input 1 types are mismatched"); - - supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported, - "Reference subtraction: input and output types are mismatched"); - - supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported, - "Reference subtraction: shapes are not suitable for implicit broadcast."); - - return supported; -} - -bool RefLayerSupport::IsPreluSupported(const TensorInfo& input, - const TensorInfo& alpha, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported) const -{ - bool supported = true; - - std::array<DataType, 4> supportedTypes - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "PReLU: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported, - "PReLU: alpha is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "PReLU: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported, - "PReLU: input, alpha and output types are mismatched"); - - supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported, - "PReLU: shapes are not suitable for implicit broadcast"); - - return supported; -} - -bool RefLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input, - const TensorInfo& output, - const TransposeConvolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported) const -{ - boost::ignore_unused(descriptor); - bool supported = true; - - std::array<DataType,4> supportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::QAsymmU8, - DataType::QSymmS16 - }; - - supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, - "Reference TransposeConvolution2d: input is not a supported type."); - - supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, - "Reference TransposeConvolution2d: output is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, - "Reference TransposeConvolution2d: input and output types mismatched."); - - - const DataType inputType = input.GetDataType(); - if (inputType == DataType::QAsymmU8) - { - ARMNN_NO_DEPRECATE_WARN_BEGIN - std::array<DataType, 3> supportedWeightTypes = - { - DataType::QAsymmU8, - DataType::QSymmS8, - DataType::QuantizedSymm8PerAxis //Deprecated - }; - ARMNN_NO_DEPRECATE_WARN_END - - supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported, - "Reference TransposeConvolution2d: weights type not supported for " - "quantized input."); - } - else - { - supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported, - "Reference TransposeConvolution2d: weights is not a supported type."); - - supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported, - "Reference TransposeConvolution2d: input and weights types mismatched."); - } - - if (biases.has_value()) - { - std::array<DataType,3> biasesSupportedTypes = - { - DataType::Float32, - DataType::Float16, - DataType::Signed32 - }; - supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported, - "Reference TransposeConvolution2d: biases is not a supported type."); - } - - return supported; -} - -} // namespace armnn diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp deleted file mode 100644 index 1551a55694..0000000000 --- a/src/backends/reference/RefLayerSupport.hpp +++ /dev/null @@ -1,323 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <backendsCommon/LayerSupportBase.hpp> - -namespace armnn -{ - -class RefLayerSupport : public LayerSupportBase -{ -public: - ARMNN_DEPRECATED_MSG("Use IsElementwiseUnarySupported instead") - bool IsAbsSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsActivationSupported(const TensorInfo& input, - const TensorInfo& output, - const ActivationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsAdditionSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsArgMinMaxSupported(const TensorInfo& input, - const TensorInfo& output, - const ArgMinMaxDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsBatchNormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& mean, - const TensorInfo& var, - const TensorInfo& beta, - const TensorInfo& gamma, - const BatchNormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsBatchToSpaceNdSupported(const TensorInfo& input, - const TensorInfo& output, - const BatchToSpaceNdDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsComparisonSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - const ComparisonDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsConcatSupported(const std::vector<const TensorInfo*> inputs, - const TensorInfo& output, - const ConcatDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsConstantSupported(const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsConvertFp16ToFp32Supported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsConvertFp32ToFp16Supported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsConvolution2dSupported(const TensorInfo& input, - const TensorInfo& output, - const Convolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsDebugSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsDepthToSpaceSupported(const TensorInfo& input, - const TensorInfo& output, - const DepthToSpaceDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsDepthwiseConvolutionSupported(const TensorInfo& input, - const TensorInfo& output, - const DepthwiseConvolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsDequantizeSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsDetectionPostProcessSupported(const TensorInfo& boxEncodings, - const TensorInfo& scores, - const TensorInfo& anchors, - const TensorInfo& detectionBoxes, - const TensorInfo& detectionClasses, - const TensorInfo& detectionScores, - const TensorInfo& numDetections, - const DetectionPostProcessDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input, - const TensorInfo& output, - const DepthwiseConvolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported = - EmptyOptional()) const override; - - bool IsDivisionSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsElementwiseUnarySupported(const TensorInfo& input, - const TensorInfo& output, - const ElementwiseUnaryDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - ARMNN_DEPRECATED_MSG("Use IsComparisonSupported instead") - bool IsEqualSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsFakeQuantizationSupported(const TensorInfo& input, - const FakeQuantizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsFloorSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsFullyConnectedSupported(const TensorInfo& input, - const TensorInfo& output, - const TensorInfo& weights, - const TensorInfo& biases, - const FullyConnectedDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsGatherSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - ARMNN_DEPRECATED_MSG("Use IsComparisonSupported instead") - bool IsGreaterSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsInputSupported(const TensorInfo& input, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsInstanceNormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const InstanceNormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsL2NormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const L2NormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsLogSoftmaxSupported(const TensorInfo& input, - const TensorInfo& output, - const LogSoftmaxDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported) const override; - - bool IsLstmSupported(const TensorInfo& input, - const TensorInfo& outputStateIn, - const TensorInfo& cellStateIn, - const TensorInfo& scratchBuffer, - const TensorInfo& outputStateOut, - const TensorInfo& cellStateOut, - const TensorInfo& output, - const LstmDescriptor& descriptor, - const LstmInputParamsInfo& paramsInfo, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsMaximumSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsMeanSupported(const TensorInfo& input, - const TensorInfo& output, - const MeanDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead") - bool IsMergerSupported(const std::vector<const TensorInfo*> inputs, - const TensorInfo& output, - const MergerDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsMemCopySupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsMinimumSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsMultiplicationSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsNormalizationSupported(const TensorInfo& input, - const TensorInfo& output, - const NormalizationDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsOutputSupported(const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsPadSupported(const TensorInfo& input, - const TensorInfo& output, - const PadDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsPermuteSupported(const TensorInfo& input, - const TensorInfo& output, - const PermuteDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsPooling2dSupported(const TensorInfo& input, - const TensorInfo& output, - const Pooling2dDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsQuantizeSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsReshapeSupported(const TensorInfo& input, - const TensorInfo& output, - const ReshapeDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsResizeBilinearSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsResizeSupported(const TensorInfo& input, - const TensorInfo& output, - const ResizeDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - ARMNN_DEPRECATED_MSG("Use IsElementwiseUnarySupported instead") - bool IsRsqrtSupported(const TensorInfo& input, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsSliceSupported(const TensorInfo& input, - const TensorInfo& output, - const SliceDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsSoftmaxSupported(const TensorInfo& input, - const TensorInfo& output, - const SoftmaxDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsSpaceToBatchNdSupported(const TensorInfo& input, - const TensorInfo& output, - const SpaceToBatchNdDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsSpaceToDepthSupported(const TensorInfo& input, - const TensorInfo& output, - const SpaceToDepthDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) - const override; - - ARMNN_DEPRECATED_MSG("Use IsSplitterSupported with outputs instead") - bool IsSplitterSupported(const TensorInfo& input, - const ViewsDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsSplitterSupported(const TensorInfo& input, - const std::vector<std::reference_wrapper<TensorInfo>>& outputs, - const ViewsDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsStackSupported(const std::vector<const TensorInfo*>& inputs, - const TensorInfo& output, - const StackDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsStridedSliceSupported(const TensorInfo& input, - const TensorInfo& output, - const StridedSliceDescriptor& descriptor, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsSubtractionSupported(const TensorInfo& input0, - const TensorInfo& input1, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsPreluSupported(const TensorInfo& input, - const TensorInfo& alpha, - const TensorInfo& output, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; - - bool IsTransposeConvolution2dSupported( - const TensorInfo& input, - const TensorInfo& output, - const TransposeConvolution2dDescriptor& descriptor, - const TensorInfo& weights, - const Optional<TensorInfo>& biases, - Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/RefMemoryManager.cpp b/src/backends/reference/RefMemoryManager.cpp deleted file mode 100644 index 4f15e39ee1..0000000000 --- a/src/backends/reference/RefMemoryManager.cpp +++ /dev/null @@ -1,101 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#include "RefMemoryManager.hpp" - -#include <boost/assert.hpp> - -#include <algorithm> - -namespace armnn -{ - -RefMemoryManager::RefMemoryManager() -{} - -RefMemoryManager::~RefMemoryManager() -{} - -RefMemoryManager::Pool* RefMemoryManager::Manage(unsigned int numBytes) -{ - if (!m_FreePools.empty()) - { - Pool* res = m_FreePools.back(); - m_FreePools.pop_back(); - res->Reserve(numBytes); - return res; - } - else - { - m_Pools.push_front(Pool(numBytes)); - return &m_Pools.front(); - } -} - -void RefMemoryManager::Allocate(RefMemoryManager::Pool* pool) -{ - BOOST_ASSERT(pool); - m_FreePools.push_back(pool); -} - -void* RefMemoryManager::GetPointer(RefMemoryManager::Pool* pool) -{ - return pool->GetPointer(); -} - -void RefMemoryManager::Acquire() -{ - for (Pool &pool: m_Pools) - { - pool.Acquire(); - } -} - -void RefMemoryManager::Release() -{ - for (Pool &pool: m_Pools) - { - pool.Release(); - } -} - -RefMemoryManager::Pool::Pool(unsigned int numBytes) - : m_Size(numBytes), - m_Pointer(nullptr) -{} - -RefMemoryManager::Pool::~Pool() -{ - if (m_Pointer) - { - Release(); - } -} - -void* RefMemoryManager::Pool::GetPointer() -{ - BOOST_ASSERT_MSG(m_Pointer, "RefMemoryManager::Pool::GetPointer() called when memory not acquired"); - return m_Pointer; -} - -void RefMemoryManager::Pool::Reserve(unsigned int numBytes) -{ - BOOST_ASSERT_MSG(!m_Pointer, "RefMemoryManager::Pool::Reserve() cannot be called after memory acquired"); - m_Size = std::max(m_Size, numBytes); -} - -void RefMemoryManager::Pool::Acquire() -{ - BOOST_ASSERT_MSG(!m_Pointer, "RefMemoryManager::Pool::Acquire() called when memory already acquired"); - m_Pointer = ::operator new(size_t(m_Size)); -} - -void RefMemoryManager::Pool::Release() -{ - BOOST_ASSERT_MSG(m_Pointer, "RefMemoryManager::Pool::Release() called when memory not acquired"); - ::operator delete(m_Pointer); - m_Pointer = nullptr; -} - -} diff --git a/src/backends/reference/RefMemoryManager.hpp b/src/backends/reference/RefMemoryManager.hpp deleted file mode 100644 index b98109018e..0000000000 --- a/src/backends/reference/RefMemoryManager.hpp +++ /dev/null @@ -1,59 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <armnn/backends/IMemoryManager.hpp> - -#include <forward_list> -#include <vector> - -namespace armnn -{ - -// An implementation of IMemoryManager to be used with RefTensorHandle -class RefMemoryManager : public IMemoryManager -{ -public: - RefMemoryManager(); - virtual ~RefMemoryManager(); - - class Pool; - - Pool* Manage(unsigned int numBytes); - - void Allocate(Pool *pool); - - void* GetPointer(Pool *pool); - - void Acquire() override; - void Release() override; - - class Pool - { - public: - Pool(unsigned int numBytes); - ~Pool(); - - void Acquire(); - void Release(); - - void* GetPointer(); - - void Reserve(unsigned int numBytes); - - private: - unsigned int m_Size; - void* m_Pointer; - }; - -private: - RefMemoryManager(const RefMemoryManager&) = delete; // Noncopyable - RefMemoryManager& operator=(const RefMemoryManager&) = delete; // Noncopyable - - std::forward_list<Pool> m_Pools; - std::vector<Pool*> m_FreePools; -}; - -} diff --git a/src/backends/reference/RefRegistryInitializer.cpp b/src/backends/reference/RefRegistryInitializer.cpp deleted file mode 100644 index a06bd8d949..0000000000 --- a/src/backends/reference/RefRegistryInitializer.cpp +++ /dev/null @@ -1,25 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefBackend.hpp" - -#include <armnn/BackendRegistry.hpp> - -namespace -{ - -using namespace armnn; - -static BackendRegistry::StaticRegistryInitializer g_RegisterHelper -{ - BackendRegistryInstance(), - RefBackend::GetIdStatic(), - []() - { - return IBackendInternalUniquePtr(new RefBackend); - } -}; - -} // Anonymous namespace diff --git a/src/backends/reference/RefTensorHandle.cpp b/src/backends/reference/RefTensorHandle.cpp deleted file mode 100644 index 84a74edc1d..0000000000 --- a/src/backends/reference/RefTensorHandle.cpp +++ /dev/null @@ -1,152 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#include "RefTensorHandle.hpp" - -namespace armnn -{ - -RefTensorHandle::RefTensorHandle(const TensorInfo &tensorInfo, std::shared_ptr<RefMemoryManager> &memoryManager): - m_TensorInfo(tensorInfo), - m_MemoryManager(memoryManager), - m_Pool(nullptr), - m_UnmanagedMemory(nullptr), - m_ImportFlags(static_cast<MemorySourceFlags>(MemorySource::Undefined)), - m_Imported(false) -{ - -} - -RefTensorHandle::RefTensorHandle(const TensorInfo& tensorInfo, std::shared_ptr<RefMemoryManager> &memoryManager, - MemorySourceFlags importFlags) - : m_TensorInfo(tensorInfo), - m_MemoryManager(memoryManager), - m_Pool(nullptr), - m_UnmanagedMemory(nullptr), - m_ImportFlags(importFlags), - m_Imported(false) -{ - -} - -RefTensorHandle::~RefTensorHandle() -{ - if (!m_Pool) - { - // unmanaged - if (!m_Imported) - { - ::operator delete(m_UnmanagedMemory); - } - } -} - -void RefTensorHandle::Manage() -{ - BOOST_ASSERT_MSG(!m_Pool, "RefTensorHandle::Manage() called twice"); - BOOST_ASSERT_MSG(!m_UnmanagedMemory, "RefTensorHandle::Manage() called after Allocate()"); - - m_Pool = m_MemoryManager->Manage(m_TensorInfo.GetNumBytes()); -} - -void RefTensorHandle::Allocate() -{ - if (!m_UnmanagedMemory) - { - if (!m_Pool) - { - // unmanaged - m_UnmanagedMemory = ::operator new(m_TensorInfo.GetNumBytes()); - } - else - { - m_MemoryManager->Allocate(m_Pool); - } - } - else - { - throw InvalidArgumentException("RefTensorHandle::Allocate Trying to allocate a RefTensorHandle" - "that already has allocated memory."); - } -} - -const void* RefTensorHandle::Map(bool /*unused*/) const -{ - return GetPointer(); -} - -void* RefTensorHandle::GetPointer() const -{ - if (m_UnmanagedMemory) - { - return m_UnmanagedMemory; - } - else - { - BOOST_ASSERT_MSG(m_Pool, "RefTensorHandle::GetPointer called on unmanaged, unallocated tensor handle"); - return m_MemoryManager->GetPointer(m_Pool); - } -} - -void RefTensorHandle::CopyOutTo(void* dest) const -{ - const void *src = GetPointer(); - BOOST_ASSERT(src); - memcpy(dest, src, m_TensorInfo.GetNumBytes()); -} - -void RefTensorHandle::CopyInFrom(const void* src) -{ - void *dest = GetPointer(); - BOOST_ASSERT(dest); - memcpy(dest, src, m_TensorInfo.GetNumBytes()); -} - -bool RefTensorHandle::Import(void* memory, MemorySource source) -{ - - if (m_ImportFlags & static_cast<MemorySourceFlags>(source)) - { - if (source == MemorySource::Malloc) - { - // Check memory alignment - constexpr uintptr_t alignment = sizeof(size_t); - if (reinterpret_cast<uintptr_t>(memory) % alignment) - { - if (m_Imported) - { - m_Imported = false; - m_UnmanagedMemory = nullptr; - } - - return false; - } - - // m_UnmanagedMemory not yet allocated. - if (!m_Imported && !m_UnmanagedMemory) - { - m_UnmanagedMemory = memory; - m_Imported = true; - return true; - } - - // m_UnmanagedMemory initially allocated with Allocate(). - if (!m_Imported && m_UnmanagedMemory) - { - return false; - } - - // m_UnmanagedMemory previously imported. - if (m_Imported) - { - m_UnmanagedMemory = memory; - return true; - } - } - } - - return false; -} - -} diff --git a/src/backends/reference/RefTensorHandle.hpp b/src/backends/reference/RefTensorHandle.hpp deleted file mode 100644 index 6cde3263a0..0000000000 --- a/src/backends/reference/RefTensorHandle.hpp +++ /dev/null @@ -1,81 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <backendsCommon/CpuTensorHandle.hpp> - -#include "RefMemoryManager.hpp" - -namespace armnn -{ - -// An implementation of ITensorHandle with simple "bump the pointer" memory-management behaviour -class RefTensorHandle : public ITensorHandle -{ -public: - RefTensorHandle(const TensorInfo& tensorInfo, std::shared_ptr<RefMemoryManager> &memoryManager); - - RefTensorHandle(const TensorInfo& tensorInfo, std::shared_ptr<RefMemoryManager> &memoryManager, - MemorySourceFlags importFlags); - - ~RefTensorHandle(); - - virtual void Manage() override; - - virtual void Allocate() override; - - virtual ITensorHandle* GetParent() const override - { - return nullptr; - } - - virtual const void* Map(bool /* blocking = true */) const override; - using ITensorHandle::Map; - - virtual void Unmap() const override - {} - - TensorShape GetStrides() const override - { - return GetUnpaddedTensorStrides(m_TensorInfo); - } - - TensorShape GetShape() const override - { - return m_TensorInfo.GetShape(); - } - - const TensorInfo& GetTensorInfo() const - { - return m_TensorInfo; - } - - virtual MemorySourceFlags GetImportFlags() const override - { - return m_ImportFlags; - } - - virtual bool Import(void* memory, MemorySource source) override; - -private: - // Only used for testing - void CopyOutTo(void*) const override; - void CopyInFrom(const void*) override; - - void* GetPointer() const; - - RefTensorHandle(const RefTensorHandle& other) = delete; // noncopyable - RefTensorHandle& operator=(const RefTensorHandle& other) = delete; //noncopyable - - TensorInfo m_TensorInfo; - - std::shared_ptr<RefMemoryManager> m_MemoryManager; - RefMemoryManager::Pool* m_Pool; - mutable void *m_UnmanagedMemory; - MemorySourceFlags m_ImportFlags; - bool m_Imported; -}; - -} diff --git a/src/backends/reference/RefTensorHandleFactory.cpp b/src/backends/reference/RefTensorHandleFactory.cpp deleted file mode 100644 index c97a779cb3..0000000000 --- a/src/backends/reference/RefTensorHandleFactory.cpp +++ /dev/null @@ -1,62 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefTensorHandleFactory.hpp" -#include "RefTensorHandle.hpp" - -#include <boost/core/ignore_unused.hpp> - -namespace armnn -{ - -using FactoryId = ITensorHandleFactory::FactoryId; - -const FactoryId& RefTensorHandleFactory::GetIdStatic() -{ - static const FactoryId s_Id(RefTensorHandleFactoryId()); - return s_Id; -} - -std::unique_ptr<ITensorHandle> RefTensorHandleFactory::CreateSubTensorHandle(ITensorHandle& parent, - TensorShape const& subTensorShape, - unsigned int const* subTensorOrigin) const -{ - boost::ignore_unused(parent, subTensorShape, subTensorOrigin); - return nullptr; -} - -std::unique_ptr<ITensorHandle> RefTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const -{ - return std::make_unique<RefTensorHandle>(tensorInfo, m_MemoryManager, m_ImportFlags); -} - -std::unique_ptr<ITensorHandle> RefTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo, - DataLayout dataLayout) const -{ - boost::ignore_unused(dataLayout); - return std::make_unique<RefTensorHandle>(tensorInfo, m_MemoryManager, m_ImportFlags); -} - -const FactoryId& RefTensorHandleFactory::GetId() const -{ - return GetIdStatic(); -} - -bool RefTensorHandleFactory::SupportsSubTensors() const -{ - return false; -} - -MemorySourceFlags RefTensorHandleFactory::GetExportFlags() const -{ - return m_ExportFlags; -} - -MemorySourceFlags RefTensorHandleFactory::GetImportFlags() const -{ - return m_ImportFlags; -} - -} // namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/RefTensorHandleFactory.hpp b/src/backends/reference/RefTensorHandleFactory.hpp deleted file mode 100644 index 8ea02f58c4..0000000000 --- a/src/backends/reference/RefTensorHandleFactory.hpp +++ /dev/null @@ -1,54 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "RefMemoryManager.hpp" - -#include <armnn/backends/ITensorHandleFactory.hpp> - -namespace armnn -{ - -constexpr const char * RefTensorHandleFactoryId() { return "Arm/Ref/TensorHandleFactory"; } - -class RefTensorHandleFactory : public ITensorHandleFactory -{ - -public: - RefTensorHandleFactory(std::shared_ptr<RefMemoryManager> mgr) - : m_MemoryManager(mgr), - m_ImportFlags(static_cast<MemorySourceFlags>(MemorySource::Malloc)), - m_ExportFlags(static_cast<MemorySourceFlags>(MemorySource::Malloc)) - {} - - std::unique_ptr<ITensorHandle> CreateSubTensorHandle(ITensorHandle& parent, - TensorShape const& subTensorShape, - unsigned int const* subTensorOrigin) const override; - - std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo) const override; - - std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo, - DataLayout dataLayout) const override; - - static const FactoryId& GetIdStatic(); - - const FactoryId& GetId() const override; - - bool SupportsSubTensors() const override; - - MemorySourceFlags GetExportFlags() const override; - - MemorySourceFlags GetImportFlags() const override; - -private: - mutable std::shared_ptr<RefMemoryManager> m_MemoryManager; - MemorySourceFlags m_ImportFlags; - MemorySourceFlags m_ExportFlags; - -}; - -} // namespace armnn - diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp deleted file mode 100644 index 02dbbabf9f..0000000000 --- a/src/backends/reference/RefWorkloadFactory.cpp +++ /dev/null @@ -1,571 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#include <Layer.hpp> -#include <backendsCommon/CpuTensorHandle.hpp> -#include <backendsCommon/MemCopyWorkload.hpp> -#include <backendsCommon/MemImportWorkload.hpp> -#include <backendsCommon/MakeWorkloadHelper.hpp> -#include "RefWorkloadFactory.hpp" -#include "RefBackendId.hpp" -#include "workloads/RefWorkloads.hpp" -#include "RefTensorHandle.hpp" - - -namespace armnn -{ - -namespace -{ -static const BackendId s_Id{RefBackendId()}; -} -template <typename F32Workload, typename U8Workload, typename QueueDescriptorType> -std::unique_ptr<IWorkload> RefWorkloadFactory::MakeWorkload(const QueueDescriptorType& descriptor, - const WorkloadInfo& info) const -{ - return MakeWorkloadHelper<NullWorkload, F32Workload, U8Workload, NullWorkload, NullWorkload, NullWorkload> - (descriptor, info); -} - -template <DataType ArmnnType> -bool IsDataType(const WorkloadInfo& info) -{ - auto checkType = [](const TensorInfo& tensorInfo) {return tensorInfo.GetDataType() == ArmnnType;}; - auto it = std::find_if(std::begin(info.m_InputTensorInfos), std::end(info.m_InputTensorInfos), checkType); - if (it != std::end(info.m_InputTensorInfos)) - { - return true; - } - it = std::find_if(std::begin(info.m_OutputTensorInfos), std::end(info.m_OutputTensorInfos), checkType); - if (it != std::end(info.m_OutputTensorInfos)) - { - return true; - } - return false; -} - -bool IsSigned32(const WorkloadInfo& info) -{ - return IsDataType<DataType::Signed32>(info); -} - -bool IsFloat16(const WorkloadInfo& info) -{ - return IsDataType<DataType::Float16>(info); -} - -bool IsQSymmS16(const WorkloadInfo& info) -{ - return IsDataType<DataType::QSymmS16>(info); -} - -bool IsQSymmS8(const WorkloadInfo& info) -{ - return IsDataType<DataType::QSymmS8>(info); -} - -bool IsQAsymmS8(const WorkloadInfo& info) -{ - return IsDataType<DataType::QAsymmS8>(info); -} - -bool IsQAsymmU8(const WorkloadInfo& info) -{ - return IsDataType<DataType::QAsymmU8>(info); -} - -RefWorkloadFactory::RefWorkloadFactory(const std::shared_ptr<RefMemoryManager>& memoryManager) - : m_MemoryManager(memoryManager) -{ -} - -RefWorkloadFactory::RefWorkloadFactory() - : m_MemoryManager(new RefMemoryManager()) -{ -} - -const BackendId& RefWorkloadFactory::GetBackendId() const -{ - return s_Id; -} - -bool RefWorkloadFactory::IsLayerSupported(const Layer& layer, - Optional<DataType> dataType, - std::string& outReasonIfUnsupported) -{ - return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported); -} - -std::unique_ptr<ITensorHandle> RefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo, - const bool isMemoryManaged) const -{ - // For Ref it is okay to make the TensorHandle memory managed as it can also store a pointer - // to unmanaged memory. This also ensures memory alignment. - boost::ignore_unused(isMemoryManaged); - return std::make_unique<RefTensorHandle>(tensorInfo, m_MemoryManager); -} - -std::unique_ptr<ITensorHandle> RefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo, - DataLayout dataLayout, - const bool isMemoryManaged) const -{ - // For Ref it is okay to make the TensorHandle memory managed as it can also store a pointer - // to unmanaged memory. This also ensures memory alignment. - boost::ignore_unused(isMemoryManaged, dataLayout); - return std::make_unique<RefTensorHandle>(tensorInfo, m_MemoryManager); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateAbs(const AbsQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - boost::ignore_unused(descriptor); - ElementwiseUnaryQueueDescriptor elementwiseUnaryDescriptor; - elementwiseUnaryDescriptor.m_Parameters.m_Operation = UnaryOperation::Abs; - - return CreateElementwiseUnary(elementwiseUnaryDescriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateActivation(const ActivationQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefActivationWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefAdditionWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateArgMinMax(const ArgMinMaxQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefArgMinMaxWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateBatchNormalization( - const BatchNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefBatchNormalizationWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefBatchToSpaceNdWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateComparison(const ComparisonQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefComparisonWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConcat(const ConcatQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefConcatWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConstant(const ConstantQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefConstantWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvertFp16ToFp32( - const ConvertFp16ToFp32QueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefConvertFp16ToFp32Workload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvertFp32ToFp16( - const ConvertFp32ToFp16QueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefConvertFp32ToFp16Workload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefConvolution2dWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDebug(const DebugQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - if (IsFloat16(info)) - { - return std::make_unique<RefDebugFloat16Workload>(descriptor, info); - } - if (IsQSymmS16(info)) - { - return std::make_unique<RefDebugQSymmS16Workload>(descriptor, info); - } - if (IsQSymmS8(info)) - { - return std::make_unique<RefDebugQSymmS8Workload>(descriptor, info); - } - if (IsQAsymmU8(info)) - { - return std::make_unique<RefDebugQAsymmU8Workload>(descriptor, info); - } - if (IsQAsymmS8(info)) - { - return std::make_unique<RefDebugQAsymmS8Workload>(descriptor, info); - } - if (IsSigned32(info)) - { - return std::make_unique<RefDebugSigned32Workload>(descriptor, info); - } - - return MakeWorkload<RefDebugFloat32Workload, RefDebugQAsymmU8Workload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDepthToSpace(const DepthToSpaceQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefDepthToSpaceWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDepthwiseConvolution2d( - const DepthwiseConvolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefDepthwiseConvolution2dWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDequantize(const DequantizeQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefDequantizeWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDetectionPostProcess( - const DetectionPostProcessQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefDetectionPostProcessWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDivision(const DivisionQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefDivisionWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateElementwiseUnary(const ElementwiseUnaryQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefElementwiseUnaryWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateEqual(const EqualQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - boost::ignore_unused(descriptor); - ComparisonQueueDescriptor comparisonDescriptor; - comparisonDescriptor.m_Parameters.m_Operation = ComparisonOperation::Equal; - - return CreateComparison(comparisonDescriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFakeQuantization( - const FakeQuantizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return MakeWorkload<RefFakeQuantizationFloat32Workload, NullWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefFloorWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFullyConnected( - const FullyConnectedQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefFullyConnectedWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateGather(const GatherQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefGatherWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateGreater(const GreaterQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - boost::ignore_unused(descriptor); - ComparisonQueueDescriptor comparisonDescriptor; - comparisonDescriptor.m_Parameters.m_Operation = ComparisonOperation::Greater; - - return CreateComparison(comparisonDescriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - if (info.m_InputTensorInfos.empty() ) - { - throw InvalidArgumentException("RefWorkloadFactory::CreateInput: Input cannot be zero length"); - } - if (info.m_OutputTensorInfos.empty()) - { - throw InvalidArgumentException("RefWorkloadFactory::CreateInput: Output cannot be zero length"); - } - - if (info.m_InputTensorInfos[0].GetNumBytes() != info.m_OutputTensorInfos[0].GetNumBytes()) - { - throw InvalidArgumentException("RefWorkloadFactory::CreateInput: data input and output differ in byte count."); - } - - return std::make_unique<CopyMemGenericWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateInstanceNormalization( - const InstanceNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefInstanceNormalizationWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefL2NormalizationWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateLogSoftmax(const LogSoftmaxQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefLogSoftmaxWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateLstm(const LstmQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefLstmWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMaximum(const MaximumQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefMaximumWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMean(const MeanQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefMeanWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMemCopy(const MemCopyQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - if (descriptor.m_Inputs.empty()) - { - throw InvalidArgumentException("RefWorkloadFactory: CreateMemCopy() expected an input tensor."); - } - return std::make_unique<CopyMemGenericWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMemImport(const MemImportQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - if (descriptor.m_Inputs.empty()) - { - throw InvalidArgumentException("RefWorkloadFactory: CreateMemImport() expected an input tensor."); - } - return std::make_unique<ImportMemGenericWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMerger(const MergerQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return CreateConcat(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMinimum(const MinimumQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefMinimumWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMultiplication(const MultiplicationQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefMultiplicationWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateNormalization(const NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefNormalizationWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateOutput(const OutputQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - if (info.m_InputTensorInfos.empty() ) - { - throw InvalidArgumentException("RefWorkloadFactory::CreateOutput: Input cannot be zero length"); - } - if (info.m_OutputTensorInfos.empty()) - { - throw InvalidArgumentException("RefWorkloadFactory::CreateOutput: Output cannot be zero length"); - } - if (info.m_InputTensorInfos[0].GetNumBytes() != info.m_OutputTensorInfos[0].GetNumBytes()) - { - throw InvalidArgumentException("RefWorkloadFactory::CreateOutput: data input and output differ in byte count."); - } - - return std::make_unique<CopyMemGenericWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePad(const PadQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - if (IsQSymmS16(info)) - { - return std::make_unique<RefPadQSymm16Workload>(descriptor, info); - } - else if (IsFloat16(info)) - { - return std::make_unique<RefPadFloat16Workload>(descriptor, info); - } - return MakeWorkload<RefPadFloat32Workload, RefPadQAsymm8Workload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePermute(const PermuteQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - if (IsQSymmS16(info)) - { - return std::make_unique<RefPermuteQSymm16Workload>(descriptor, info); - } - return MakeWorkloadHelper<RefPermuteFloat16Workload, RefPermuteFloat32Workload, RefPermuteQAsymm8Workload, - NullWorkload, NullWorkload, NullWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePooling2d(const Pooling2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefPooling2dWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePreCompiled(const PreCompiledQueueDescriptor& /*descriptor*/, - const WorkloadInfo& /*info*/) const -{ - return nullptr; -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePrelu(const PreluQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefPreluWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateQuantize(const QuantizeQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefQuantizeWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateReshape(const ReshapeQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefReshapeWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateResize(const ResizeQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefResizeWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateResizeBilinear(const ResizeBilinearQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - ResizeQueueDescriptor resizeDescriptor; - resizeDescriptor.m_Parameters.m_Method = ResizeMethod::Bilinear; - resizeDescriptor.m_Parameters.m_DataLayout = descriptor.m_Parameters.m_DataLayout; - resizeDescriptor.m_Parameters.m_TargetWidth = descriptor.m_Parameters.m_TargetWidth; - resizeDescriptor.m_Parameters.m_TargetHeight = descriptor.m_Parameters.m_TargetHeight; - - return CreateResize(resizeDescriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateRsqrt(const RsqrtQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - boost::ignore_unused(descriptor); - ElementwiseUnaryQueueDescriptor elementwiseUnaryDescriptor; - elementwiseUnaryDescriptor.m_Parameters.m_Operation = UnaryOperation::Rsqrt; - - return CreateElementwiseUnary(elementwiseUnaryDescriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSlice(const SliceQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefSliceWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefSoftmaxWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefSpaceToBatchNdWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSpaceToDepth(const SpaceToDepthQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefSpaceToDepthWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefSplitterWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateStack(const StackQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefStackWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateStridedSlice(const StridedSliceQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefStridedSliceWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSubtraction(const SubtractionQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefSubtractionWorkload>(descriptor, info); -} - -std::unique_ptr<IWorkload> RefWorkloadFactory::CreateTransposeConvolution2d( - const TransposeConvolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const -{ - return std::make_unique<RefTransposeConvolution2dWorkload>(descriptor, info); -} - -} // namespace armnn diff --git a/src/backends/reference/RefWorkloadFactory.hpp b/src/backends/reference/RefWorkloadFactory.hpp deleted file mode 100644 index b5b9b0faf0..0000000000 --- a/src/backends/reference/RefWorkloadFactory.hpp +++ /dev/null @@ -1,249 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <armnn/Optional.hpp> -#include <backendsCommon/WorkloadFactory.hpp> - -#include "RefMemoryManager.hpp" - -#include <boost/core/ignore_unused.hpp> - - -namespace armnn -{ - -template <typename QueueDescriptorType> -constexpr bool IsOperationQueueDescriptor(const QueueDescriptorType&) { return true; } - -template <> -constexpr bool IsOperationQueueDescriptor(const MemCopyQueueDescriptor&) { return false; } - -template <> -constexpr bool IsOperationQueueDescriptor(const ConstantQueueDescriptor&) { return false; } - -template <> -constexpr bool IsOperationQueueDescriptor(const PermuteQueueDescriptor&) { return false; } - -// Reference workload factory. -class RefWorkloadFactory : public IWorkloadFactory -{ -public: - explicit RefWorkloadFactory(const std::shared_ptr<RefMemoryManager>& memoryManager); - RefWorkloadFactory(); - - ~RefWorkloadFactory() {} - - const BackendId& GetBackendId() const override; - - static bool IsLayerSupported(const Layer& layer, - Optional<DataType> dataType, - std::string& outReasonIfUnsupported); - - bool SupportsSubTensors() const override { return false; } - - std::unique_ptr<ITensorHandle> CreateSubTensorHandle(ITensorHandle& parent, - TensorShape const& subTensorShape, - unsigned int const* subTensorOrigin) const override - { - boost::ignore_unused(parent, subTensorShape, subTensorOrigin); - return nullptr; - } - - std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo, - const bool IsMemoryManaged = true) const override; - - std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo, - DataLayout dataLayout, - const bool IsMemoryManaged = true) const override; - - ARMNN_DEPRECATED_MSG("Use CreateElementwiseUnary instead") - std::unique_ptr<IWorkload> CreateAbs(const AbsQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateActivation(const ActivationQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateAddition(const AdditionQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateArgMinMax(const ArgMinMaxQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateBatchNormalization(const BatchNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateComparison(const ComparisonQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateConcat(const ConcatQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateConstant(const ConstantQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateConvertFp16ToFp32(const ConvertFp16ToFp32QueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateConvertFp32ToFp16(const ConvertFp32ToFp16QueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateDebug(const DebugQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateDepthToSpace(const DepthToSpaceQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateDepthwiseConvolution2d(const DepthwiseConvolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateDequantize(const DequantizeQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateDetectionPostProcess(const DetectionPostProcessQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateDivision(const DivisionQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateElementwiseUnary(const ElementwiseUnaryQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - ARMNN_DEPRECATED_MSG("Use CreateComparison instead") - std::unique_ptr<IWorkload> CreateEqual(const EqualQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateFakeQuantization(const FakeQuantizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateFloor(const FloorQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateFullyConnected(const FullyConnectedQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateGather(const GatherQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - ARMNN_DEPRECATED_MSG("Use CreateComparison instead") - std::unique_ptr<IWorkload> CreateGreater(const GreaterQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateInput(const InputQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateInstanceNormalization(const InstanceNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateLogSoftmax(const LogSoftmaxQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateLstm(const LstmQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateMaximum(const MaximumQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateMean(const MeanQueueDescriptor& descriptor, - const WorkloadInfo& Info) const override; - - std::unique_ptr<IWorkload> CreateMemCopy(const MemCopyQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateMemImport(const MemImportQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - ARMNN_DEPRECATED_MSG("Use CreateConcat instead") - std::unique_ptr<IWorkload> CreateMerger(const MergerQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateMinimum(const MinimumQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateMultiplication(const MultiplicationQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateNormalization(const NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateOutput(const OutputQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreatePad(const PadQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreatePermute(const PermuteQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreatePooling2d(const Pooling2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreatePreCompiled(const PreCompiledQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreatePrelu(const PreluQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateQuantize(const QuantizeQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateReshape(const ReshapeQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateResize(const ResizeQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - ARMNN_DEPRECATED_MSG("Use CreateResize instead") - std::unique_ptr<IWorkload> CreateResizeBilinear(const ResizeBilinearQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - ARMNN_DEPRECATED_MSG("Use CreateElementwiseUnary instead") - std::unique_ptr<IWorkload> CreateRsqrt(const RsqrtQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateSlice(const SliceQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateSoftmax(const SoftmaxQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateSpaceToDepth(const SpaceToDepthQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateSplitter(const SplitterQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateStack(const StackQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateStridedSlice(const StridedSliceQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateSubtraction(const SubtractionQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - - std::unique_ptr<IWorkload> CreateTransposeConvolution2d(const TransposeConvolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info) const override; - -private: - template <typename F32Workload, typename U8Workload, typename QueueDescriptorType> - std::unique_ptr<IWorkload> MakeWorkload(const QueueDescriptorType& descriptor, const WorkloadInfo& info) const; - - mutable std::shared_ptr<RefMemoryManager> m_MemoryManager; -}; - -} // namespace armnn diff --git a/src/backends/reference/backend.cmake b/src/backends/reference/backend.cmake deleted file mode 100644 index e8654d8741..0000000000 --- a/src/backends/reference/backend.cmake +++ /dev/null @@ -1,14 +0,0 @@ -# -# Copyright © 2017 Arm Ltd. All rights reserved. -# SPDX-License-Identifier: MIT -# - -add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/reference) -list(APPEND armnnLibraries armnnRefBackend) - -if(ARMNNREF) - list(APPEND armnnLibraries armnnRefBackendWorkloads) - list(APPEND armnnUnitTestLibraries armnnRefBackendUnitTests) -else() - message(STATUS "Reference backend is disabled") -endif() diff --git a/src/backends/reference/backend.mk b/src/backends/reference/backend.mk deleted file mode 100644 index 412dc9438c..0000000000 --- a/src/backends/reference/backend.mk +++ /dev/null @@ -1,134 +0,0 @@ -# -# Copyright © 2017 ARM Ltd. All rights reserved. -# SPDX-License-Identifier: MIT -# - -# BACKEND_SOURCES contains the list of files to be included -# in the Android build and it is picked up by the Android.mk -# file in the root of ArmNN - -# The variable to enable/disable the reference backend (ARMNN_REF_ENABLED is declared in android-nn-driver/Android.mk) -ifeq ($(ARMNN_REF_ENABLED),1) - -# ARMNN_REF_ENABLED == 1 -# Include the source files for the reference backend - -BACKEND_SOURCES := \ - RefBackend.cpp \ - RefLayerSupport.cpp \ - RefMemoryManager.cpp \ - RefTensorHandle.cpp \ - RefWorkloadFactory.cpp \ - RefRegistryInitializer.cpp \ - RefTensorHandleFactory.cpp \ - workloads/Activation.cpp \ - workloads/ArgMinMax.cpp \ - workloads/BatchNormImpl.cpp \ - workloads/BatchToSpaceNd.cpp \ - workloads/Broadcast.cpp \ - workloads/ConvImpl.cpp \ - workloads/Debug.cpp \ - workloads/DepthToSpace.cpp \ - workloads/DetectionPostProcess.cpp \ - workloads/Dequantize.cpp \ - workloads/ElementwiseFunction.cpp \ - workloads/FullyConnected.cpp \ - workloads/Gather.cpp \ - workloads/InstanceNorm.cpp \ - workloads/LogSoftmax.cpp \ - workloads/LstmUtils.cpp \ - workloads/Mean.cpp \ - workloads/Concatenate.cpp \ - workloads/Pad.cpp \ - workloads/Pooling2d.cpp \ - workloads/PreluImpl.cpp \ - workloads/RefActivationWorkload.cpp \ - workloads/RefArgMinMaxWorkload.cpp \ - workloads/RefBatchNormalizationWorkload.cpp \ - workloads/RefBatchToSpaceNdWorkload.cpp \ - workloads/RefComparisonWorkload.cpp \ - workloads/RefConcatWorkload.cpp \ - workloads/RefConstantWorkload.cpp \ - workloads/RefConvertFp16ToFp32Workload.cpp \ - workloads/RefConvertFp32ToFp16Workload.cpp \ - workloads/RefConvolution2dWorkload.cpp \ - workloads/RefDebugWorkload.cpp \ - workloads/RefDepthToSpaceWorkload.cpp \ - workloads/RefDepthwiseConvolution2dWorkload.cpp \ - workloads/RefDequantizeWorkload.cpp \ - workloads/RefDetectionPostProcessWorkload.cpp \ - workloads/RefElementwiseWorkload.cpp \ - workloads/RefElementwiseUnaryWorkload.cpp \ - workloads/RefFakeQuantizationFloat32Workload.cpp \ - workloads/RefFloorWorkload.cpp \ - workloads/RefFullyConnectedWorkload.cpp \ - workloads/RefGatherWorkload.cpp \ - workloads/RefInstanceNormalizationWorkload.cpp \ - workloads/RefL2NormalizationWorkload.cpp \ - workloads/RefLogSoftmaxWorkload.cpp \ - workloads/RefLstmWorkload.cpp \ - workloads/RefMeanWorkload.cpp \ - workloads/RefNormalizationWorkload.cpp \ - workloads/RefPadWorkload.cpp \ - workloads/RefPermuteWorkload.cpp \ - workloads/RefPooling2dWorkload.cpp \ - workloads/RefPreluWorkload.cpp \ - workloads/RefQuantizeWorkload.cpp \ - workloads/RefReshapeWorkload.cpp \ - workloads/RefResizeBilinearWorkload.cpp \ - workloads/RefResizeWorkload.cpp \ - workloads/RefSliceWorkload.cpp \ - workloads/RefSoftmaxWorkload.cpp \ - workloads/RefSpaceToBatchNdWorkload.cpp \ - workloads/RefSpaceToDepthWorkload.cpp \ - workloads/RefStackWorkload.cpp \ - workloads/RefStridedSliceWorkload.cpp \ - workloads/RefSplitterWorkload.cpp \ - workloads/RefTransposeConvolution2dWorkload.cpp \ - workloads/Resize.cpp \ - workloads/Slice.cpp \ - workloads/SpaceToBatchNd.cpp \ - workloads/SpaceToDepth.cpp \ - workloads/Stack.cpp \ - workloads/StridedSlice.cpp \ - workloads/StringMapping.cpp \ - workloads/Softmax.cpp \ - workloads/Splitter.cpp \ - workloads/TransposeConvolution2d.cpp -else - -# ARMNN_REF_ENABLED == 0 -# No source file will be compiled for the reference backend - -BACKEND_SOURCES := - -endif - -# BACKEND_TEST_SOURCES contains the list of files to be included -# in the Android unit test build (armnn-tests) and it is picked -# up by the Android.mk file in the root of ArmNN - -# The variable to enable/disable the CL backend (ARMNN_REF_ENABLED is declared in android-nn-driver/Android.mk) -ifeq ($(ARMNN_REF_ENABLED),1) - -# ARMNN_REF_ENABLED == 1 -# Include the source files for the CL backend tests - -BACKEND_TEST_SOURCES := \ - test/RefCreateWorkloadTests.cpp \ - test/RefDetectionPostProcessTests.cpp \ - test/RefEndToEndTests.cpp \ - test/RefJsonPrinterTests.cpp \ - test/RefLayerSupportTests.cpp \ - test/RefLayerTests.cpp \ - test/RefMemoryManagerTests.cpp \ - test/RefOptimizedNetworkTests.cpp \ - test/RefRuntimeTests.cpp -else - -# ARMNN_REF_ENABLED == 0 -# No source file will be compiled for the reference backend tests - -BACKEND_TEST_SOURCES := - -endif diff --git a/src/backends/reference/test/ArgMinMaxTests.cpp b/src/backends/reference/test/ArgMinMaxTests.cpp deleted file mode 100644 index 201a2c0c2e..0000000000 --- a/src/backends/reference/test/ArgMinMaxTests.cpp +++ /dev/null @@ -1,58 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <reference/workloads/ArgMinMax.hpp> - -#include <boost/test/unit_test.hpp> - -BOOST_AUTO_TEST_SUITE(RefArgMinMax) - -BOOST_AUTO_TEST_CASE(ArgMinTest) -{ - const armnn::TensorInfo inputInfo({ 1, 2, 3 } , armnn::DataType::Float32); - const armnn::TensorInfo outputInfo({ 1, 3 }, armnn::DataType::Float32); - - std::vector<float> inputValues({ 1.0f, 5.0f, 3.0f, 4.0f, 2.0f, 6.0f}); - std::vector<int32_t> outputValues(outputInfo.GetNumElements()); - std::vector<int32_t> expectedValues({ 0, 1, 0 }); - - ArgMinMax(*armnn::MakeDecoder<float>(inputInfo, inputValues.data()), - outputValues.data(), - inputInfo, - outputInfo, - armnn::ArgMinMaxFunction::Min, - -2); - - BOOST_CHECK_EQUAL_COLLECTIONS(outputValues.begin(), - outputValues.end(), - expectedValues.begin(), - expectedValues.end()); - -} - -BOOST_AUTO_TEST_CASE(ArgMaxTest) -{ - const armnn::TensorInfo inputInfo({ 1, 2, 3 } , armnn::DataType::Float32); - const armnn::TensorInfo outputInfo({ 1, 3 }, armnn::DataType::Float32); - - std::vector<float> inputValues({ 1.0f, 5.0f, 3.0f, 4.0f, 2.0f, 6.0f }); - std::vector<int32_t> outputValues(outputInfo.GetNumElements()); - std::vector<int32_t> expectedValues({ 1, 0, 1 }); - - ArgMinMax(*armnn::MakeDecoder<float>(inputInfo, inputValues.data()), - outputValues.data(), - inputInfo, - outputInfo, - armnn::ArgMinMaxFunction::Max, - -2); - - BOOST_CHECK_EQUAL_COLLECTIONS(outputValues.begin(), - outputValues.end(), - expectedValues.begin(), - expectedValues.end()); - -} - -BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file diff --git a/src/backends/reference/test/CMakeLists.txt b/src/backends/reference/test/CMakeLists.txt deleted file mode 100644 index 191325db83..0000000000 --- a/src/backends/reference/test/CMakeLists.txt +++ /dev/null @@ -1,25 +0,0 @@ -# -# Copyright © 2017 Arm Ltd. All rights reserved. -# SPDX-License-Identifier: MIT -# - -list(APPEND armnnRefBackendUnitTests_sources - ArgMinMaxTests.cpp - RefCreateWorkloadTests.cpp - RefDetectionPostProcessTests.cpp - RefEndToEndTests.cpp - RefJsonPrinterTests.cpp - RefLayerSupportTests.cpp - RefLayerTests.cpp - RefMemoryManagerTests.cpp - RefOptimizedNetworkTests.cpp - RefRuntimeTests.cpp - RefTensorHandleTests.cpp - RefWorkloadFactoryHelper.hpp -) - -add_library(armnnRefBackendUnitTests OBJECT ${armnnRefBackendUnitTests_sources}) -target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn) -target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils) -target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends) -target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/profiling) diff --git a/src/backends/reference/test/RefCreateWorkloadTests.cpp b/src/backends/reference/test/RefCreateWorkloadTests.cpp deleted file mode 100644 index b83d205970..0000000000 --- a/src/backends/reference/test/RefCreateWorkloadTests.cpp +++ /dev/null @@ -1,1079 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <test/CreateWorkload.hpp> - -#include <reference/RefTensorHandle.hpp> -#include <reference/RefWorkloadFactory.hpp> -#include <reference/workloads/RefWorkloads.hpp> - -namespace -{ - -template<typename Workload> -void CheckInputOutput(std::unique_ptr<Workload> workload, const TensorInfo& inputInfo, const TensorInfo& outputInfo) -{ - auto queueDescriptor = workload->GetData(); - auto inputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Inputs[0]); - auto outputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]); - BOOST_TEST((inputHandle->GetTensorInfo() == inputInfo)); - BOOST_TEST((outputHandle->GetTensorInfo() == outputInfo)); -} - -template <typename Workload> -void CheckInputsOutput(std::unique_ptr<Workload> workload, - const TensorInfo& inputInfo0, - const TensorInfo& inputInfo1, - const TensorInfo& outputInfo) -{ - auto queueDescriptor = workload->GetData(); - auto inputHandle0 = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Inputs[0]); - auto inputHandle1 = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Inputs[1]); - auto outputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]); - BOOST_TEST((inputHandle0->GetTensorInfo() == inputInfo0)); - BOOST_TEST((inputHandle1->GetTensorInfo() == inputInfo1)); - BOOST_TEST((outputHandle->GetTensorInfo() == outputInfo)); -} - -armnn::RefWorkloadFactory GetFactory() -{ - std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>(); - return RefWorkloadFactory(memoryManager); -} - - -} - -BOOST_AUTO_TEST_SUITE(CreateWorkloadRef) - -template <typename ActivationWorkloadType, armnn::DataType DataType> -static void RefCreateActivationWorkloadTest() -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateActivationWorkloadTest<ActivationWorkloadType, DataType>(factory, graph); - - // Checks that outputs are as we expect them (see definition of CreateActivationWorkloadTest). - CheckInputOutput(std::move(workload), - TensorInfo({ 1, 1 }, DataType), - TensorInfo({ 1, 1 }, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateActivationFloat32Workload) -{ - RefCreateActivationWorkloadTest<RefActivationWorkload, armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateActivationUint8Workload) -{ - RefCreateActivationWorkloadTest<RefActivationWorkload, armnn::DataType::QAsymmU8>(); -} - -template <typename WorkloadType, - typename DescriptorType, - typename LayerType, - armnn::DataType DataType> -static void RefCreateElementwiseWorkloadTest() -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>( - factory, graph); - - CheckInputsOutput(std::move(workload), - TensorInfo({ 2, 3 }, DataType), - TensorInfo({ 2, 3 }, DataType), - TensorInfo({ 2, 3 }, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateAdditionFloatWorkload) -{ - RefCreateElementwiseWorkloadTest<RefAdditionWorkload, - AdditionQueueDescriptor, - AdditionLayer, - armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateAdditionUint8Workload) -{ - RefCreateElementwiseWorkloadTest<RefAdditionWorkload, - AdditionQueueDescriptor, - AdditionLayer, - armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateAdditionInt16Workload) -{ - RefCreateElementwiseWorkloadTest<RefAdditionWorkload, - AdditionQueueDescriptor, - AdditionLayer, - armnn::DataType::QSymmS16>(); -} - -BOOST_AUTO_TEST_CASE(CreateSubtractionFloat32Workload) -{ - RefCreateElementwiseWorkloadTest<RefSubtractionWorkload, - SubtractionQueueDescriptor, - SubtractionLayer, - armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload) -{ - RefCreateElementwiseWorkloadTest<RefSubtractionWorkload, - SubtractionQueueDescriptor, - SubtractionLayer, - armnn::DataType::Float16>(); -} - -BOOST_AUTO_TEST_CASE(CreateSubtractionUint8Workload) -{ - RefCreateElementwiseWorkloadTest<RefSubtractionWorkload, - SubtractionQueueDescriptor, - SubtractionLayer, - armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateSubtractionInt16Workload) -{ - RefCreateElementwiseWorkloadTest<RefSubtractionWorkload, - SubtractionQueueDescriptor, - SubtractionLayer, - armnn::DataType::QSymmS16>(); -} - -BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkload) -{ - RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload, - MultiplicationQueueDescriptor, - MultiplicationLayer, - armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateMultiplicationUint8Workload) -{ - RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload, - MultiplicationQueueDescriptor, - MultiplicationLayer, - armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateMultiplicationInt16Workload) -{ - RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload, - MultiplicationQueueDescriptor, - MultiplicationLayer, - armnn::DataType::QSymmS16>(); -} - -BOOST_AUTO_TEST_CASE(CreateDivisionFloat32Workload) -{ - RefCreateElementwiseWorkloadTest<RefDivisionWorkload, - DivisionQueueDescriptor, - DivisionLayer, - armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateDivisionFloat16Workload) -{ - RefCreateElementwiseWorkloadTest<RefDivisionWorkload, - DivisionQueueDescriptor, - DivisionLayer, - armnn::DataType::Float16>(); -} - -BOOST_AUTO_TEST_CASE(CreateDivisionUint8Workload) -{ - RefCreateElementwiseWorkloadTest<RefDivisionWorkload, - DivisionQueueDescriptor, - DivisionLayer, - armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateDivisionInt16Workload) -{ - RefCreateElementwiseWorkloadTest<RefDivisionWorkload, - DivisionQueueDescriptor, - DivisionLayer, - armnn::DataType::QSymmS16>(); -} - -template <typename BatchNormalizationWorkloadType, armnn::DataType DataType> -static void RefCreateBatchNormalizationWorkloadTest(DataLayout dataLayout) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>(factory, - graph, - dataLayout); - - TensorShape inputShape; - TensorShape outputShape; - - switch (dataLayout) - { - case DataLayout::NHWC: - inputShape = { 2, 4, 4, 3 }; - outputShape = { 2, 4, 4, 3 }; - break; - case DataLayout::NCHW: - default: - inputShape = { 2, 3, 4, 4 }; - outputShape = { 2, 3, 4, 4 }; - break; - } - - // Checks that outputs and inputs are as we expect them (see definition of CreateBatchNormalizationWorkloadTest). - CheckInputOutput(std::move(workload), TensorInfo(inputShape, DataType), TensorInfo(outputShape, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat32Workload) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload,armnn::DataType::Float32> - (DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat32WorkloadNhwc) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::Float32> - (DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16Workload) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload,armnn::DataType::Float16> - (DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16WorkloadNhwc) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::Float16> - (DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationUint8Workload) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QAsymmU8> - (DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationUint8WorkloadNhwc) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QAsymmU8> - (DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationInt16Workload) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QSymmS16> - (DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationInt16WorkloadNhwc) -{ - RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QSymmS16> - (DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateConvertFp16ToFp32Float32Workload) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateConvertFp16ToFp32WorkloadTest<RefConvertFp16ToFp32Workload>(factory, graph); - - // Checks that outputs and inputs are as we expect them - CheckInputOutput( - std::move(workload), TensorInfo({1, 3, 2, 3}, DataType::Float16), TensorInfo({1, 3, 2, 3}, DataType::Float32)); -} - -BOOST_AUTO_TEST_CASE(CreateConvertFp32ToFp16Float16Workload) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateConvertFp32ToFp16WorkloadTest<RefConvertFp32ToFp16Workload>(factory, graph); - - // Checks that outputs and inputs are as we expect them - CheckInputOutput( - std::move(workload), TensorInfo({1, 3, 2, 3}, DataType::Float32), TensorInfo({1, 3, 2, 3}, DataType::Float16)); -} - -static void RefCreateConvolution2dWorkloadTest(DataLayout dataLayout = DataLayout::NCHW) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateConvolution2dWorkloadTest<RefConvolution2dWorkload, DataType::Float32> - (factory, graph, dataLayout); - - TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16}) - : std::initializer_list<unsigned int>({2, 8, 16, 3}); - TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10}) - : std::initializer_list<unsigned int>({2, 2, 10, 2}); - - // Checks that outputs and inputs are as we expect them (see definition of CreateConvolution2dWorkloadTest). - CheckInputOutput(std::move(workload), - TensorInfo(inputShape, DataType::Float32), - TensorInfo(outputShape, DataType::Float32)); -} - -BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNchwWorkload) -{ - RefCreateConvolution2dWorkloadTest(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNhwcWorkload) -{ - RefCreateConvolution2dWorkloadTest(DataLayout::NHWC); -} - -static void RefCreateDepthwiseConvolutionWorkloadTest(DataLayout dataLayout) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateDepthwiseConvolution2dWorkloadTest<RefDepthwiseConvolution2dWorkload, DataType::Float32> - (factory, graph, dataLayout); - - TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 }) - : std::initializer_list<unsigned int>({ 2, 5, 5, 2 }); - TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 }) - : std::initializer_list<unsigned int>({ 2, 5, 5, 2 }); - - // Checks that inputs/outputs are as we expect them (see definition of CreateDepthwiseConvolution2dWorkloadTest). - CheckInputOutput(std::move(workload), - TensorInfo(inputShape, DataType::Float32), - TensorInfo(outputShape, DataType::Float32)); -} - -BOOST_AUTO_TEST_CASE(CreateDepthwiseConvolutionFloat32NhwcWorkload) -{ - RefCreateDepthwiseConvolutionWorkloadTest(DataLayout::NHWC); -} - -template <typename FullyConnectedWorkloadType, armnn::DataType DataType> -static void RefCreateFullyConnectedWorkloadTest() -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph); - - // Checks that outputs and inputs are as we expect them (see definition of CreateFullyConnectedWorkloadTest). - float inputsQScale = DataType == armnn::DataType::QAsymmU8 ? 1.0f : 0.0; - float outputQScale = DataType == armnn::DataType::QAsymmU8 ? 2.0f : 0.0; - CheckInputOutput(std::move(workload), - TensorInfo({ 3, 1, 4, 5 }, DataType, inputsQScale), - TensorInfo({ 3, 7 }, DataType, outputQScale)); -} - -BOOST_AUTO_TEST_CASE(CreateFullyConnectedWorkloadFloat32) -{ - RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateFullyConnectedWorkloadQuantisedAsymm8) -{ - RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateFullyConnectedWorkloadQuantisedSymm16) -{ - RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::QSymmS16>(); -} - -template <typename NormalizationWorkloadType, armnn::DataType DataType> -static void RefCreateNormalizationWorkloadTest(DataLayout dataLayout) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout); - - TensorShape inputShape; - TensorShape outputShape; - - switch (dataLayout) - { - case DataLayout::NHWC: - inputShape = { 3, 1, 5, 5 }; - outputShape = { 3, 1, 5, 5 }; - break; - case DataLayout::NCHW: - default: - inputShape = { 3, 5, 5, 1 }; - outputShape = { 3, 5, 5, 1 }; - break; - } - - // Checks that outputs and inputs are as we expect them (see definition of CreateNormalizationWorkloadTest). - CheckInputOutput(std::move(workload), TensorInfo(inputShape, DataType), TensorInfo(outputShape, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateRefNormalizationFloat32NchwWorkload) -{ - RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::Float32>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateRefNormalizationFloat32NhwcWorkload) -{ - RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::Float32>(DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateRefNormalizationUint8NchwWorkload) -{ - RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateRefNormalizationUint8NhwcWorkload) -{ - RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateRefNormalizationInt16NchwWorkload) -{ - RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateRefNormalizationInt16NhwcWorkload) -{ - RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC); -} - -template <typename Pooling2dWorkloadType, armnn::DataType DataType> -static void RefCreatePooling2dWorkloadTest(DataLayout dataLayout) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreatePooling2dWorkloadTest<Pooling2dWorkloadType, DataType>(factory, graph, dataLayout); - - TensorShape inputShape; - TensorShape outputShape; - - switch (dataLayout) - { - case DataLayout::NHWC: - inputShape = { 3, 5, 5, 2 }; - outputShape = { 3, 2, 4, 2 }; - break; - case DataLayout::NCHW: - default: - inputShape = { 3, 2, 5, 5 }; - outputShape = { 3, 2, 2, 4 }; - } - - // Checks that outputs and inputs are as we expect them (see definition of CreatePooling2dWorkloadTest). - CheckInputOutput(std::move(workload), - TensorInfo(inputShape, DataType), - TensorInfo(outputShape, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreatePooling2dFloat32Workload) -{ - RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreatePooling2dFloat32NhwcWorkload) -{ - RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreatePooling2dUint8Workload) -{ - RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreatePooling2dUint8NhwcWorkload) -{ - RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreatePooling2dInt16Workload) -{ - RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreatePooling2dInt16NhwcWorkload) -{ - RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC); -} - -template <typename SoftmaxWorkloadType, armnn::DataType DataType> -static void RefCreateSoftmaxWorkloadTest() -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph); - - // Checks that outputs and inputs are as we expect them (see definition of CreateSoftmaxWorkloadTest). - CheckInputOutput( - std::move(workload), - TensorInfo({4, 1}, DataType), - TensorInfo({4, 1}, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat32Workload) -{ - RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16Workload) -{ - RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float16>(); -} - -BOOST_AUTO_TEST_CASE(CreateSoftmaxQuantisedAsymm8Workload) -{ - RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateSoftmaxQuantisedSymm16Workload) -{ - RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QSymmS16>(); -} - -template <typename SplitterWorkloadType, armnn::DataType DataType> -static void RefCreateSplitterWorkloadTest() -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateSplitterWorkloadTest<SplitterWorkloadType, DataType>(factory, graph); - - // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest). - SplitterQueueDescriptor queueDescriptor = workload->GetData(); - auto inputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Inputs[0]); - BOOST_TEST((inputHandle->GetTensorInfo() == TensorInfo({ 5, 7, 7 }, DataType))); - - auto outputHandle0 = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]); - BOOST_TEST((outputHandle0->GetTensorInfo() == TensorInfo({ 1, 7, 7 }, DataType))); - - auto outputHandle1 = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[1]); - BOOST_TEST((outputHandle1->GetTensorInfo() == TensorInfo({ 2, 7, 7 }, DataType))); - - auto outputHandle2 = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[2]); - BOOST_TEST((outputHandle2->GetTensorInfo() == TensorInfo({ 2, 7, 7 }, DataType))); -} - -BOOST_AUTO_TEST_CASE(CreateSplitterFloat32Workload) -{ - RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateSplitterFloat16Workload) -{ - RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float16>(); -} - -BOOST_AUTO_TEST_CASE(CreateSplitterUint8Workload) -{ - RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::QAsymmU8>(); -} - -template <typename SplitterWorkloadType, typename ConcatWorkloadType, armnn::DataType DataType> -static void RefCreateSplitterConcatWorkloadTest() -{ - // Tests that it is possible to decide which output of the splitter layer - // should be lined to which input of the concat layer. - // We tested that is is possible to specify 0th output - // of the splitter to be the 1st input to the concat and the 1st output of the splitter to be 0th input - // of the concat. - - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workloads = CreateSplitterConcatWorkloadTest<SplitterWorkloadType, ConcatWorkloadType, DataType> - (factory, graph); - - auto wlSplitter = std::move(workloads.first); - auto wlConcat = std::move(workloads.second); - - //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction. - armnn::RefTensorHandle* sOut0 = dynamic_cast<armnn::RefTensorHandle*>(wlSplitter->GetData().m_Outputs[0]); - armnn::RefTensorHandle* sOut1 = dynamic_cast<armnn::RefTensorHandle*>(wlSplitter->GetData().m_Outputs[1]); - armnn::RefTensorHandle* mIn0 = dynamic_cast<armnn::RefTensorHandle*>(wlConcat->GetData().m_Inputs[0]); - armnn::RefTensorHandle* mIn1 = dynamic_cast<armnn::RefTensorHandle*>(wlConcat->GetData().m_Inputs[1]); - - BOOST_TEST(sOut0); - BOOST_TEST(sOut1); - BOOST_TEST(mIn0); - BOOST_TEST(mIn1); - - bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0); - - BOOST_TEST(validDataPointers); -} - -BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloat32) -{ - RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloat16) -{ - RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float16>(); -} - -BOOST_AUTO_TEST_CASE(CreateSplitterConcatUint8) -{ - RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::QAsymmU8>(); -} - -template <typename SplitterWorkloadType, typename ActivationWorkloadType, armnn::DataType DataType> -static void RefCreateSingleOutputMultipleInputsTest() -{ - // Tests that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer. - // We created a splitter with two outputs. That each of those outputs is used by two different activation layers. - - Graph graph; - RefWorkloadFactory factory = GetFactory(); - std::unique_ptr<SplitterWorkloadType> wlSplitter; - std::unique_ptr<ActivationWorkloadType> wlActiv0_0; - std::unique_ptr<ActivationWorkloadType> wlActiv0_1; - std::unique_ptr<ActivationWorkloadType> wlActiv1_0; - std::unique_ptr<ActivationWorkloadType> wlActiv1_1; - - CreateSplitterMultipleInputsOneOutputWorkloadTest<SplitterWorkloadType, - ActivationWorkloadType, DataType>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1, wlActiv1_0, wlActiv1_1); - - armnn::RefTensorHandle* sOut0 = dynamic_cast<armnn::RefTensorHandle*>(wlSplitter->GetData().m_Outputs[0]); - armnn::RefTensorHandle* sOut1 = dynamic_cast<armnn::RefTensorHandle*>(wlSplitter->GetData().m_Outputs[1]); - armnn::RefTensorHandle* activ0_0Im = dynamic_cast<armnn::RefTensorHandle*>(wlActiv0_0->GetData().m_Inputs[0]); - armnn::RefTensorHandle* activ0_1Im = dynamic_cast<armnn::RefTensorHandle*>(wlActiv0_1->GetData().m_Inputs[0]); - armnn::RefTensorHandle* activ1_0Im = dynamic_cast<armnn::RefTensorHandle*>(wlActiv1_0->GetData().m_Inputs[0]); - armnn::RefTensorHandle* activ1_1Im = dynamic_cast<armnn::RefTensorHandle*>(wlActiv1_1->GetData().m_Inputs[0]); - - - BOOST_TEST(sOut0); - BOOST_TEST(sOut1); - BOOST_TEST(activ0_0Im); - BOOST_TEST(activ0_1Im); - BOOST_TEST(activ1_0Im); - BOOST_TEST(activ1_1Im); - - bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) && - (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im); - - BOOST_TEST(validDataPointers); -} - -BOOST_AUTO_TEST_CASE(CreateSingleOutputMultipleInputsFloat32) -{ - RefCreateSingleOutputMultipleInputsTest<RefSplitterWorkload, RefActivationWorkload, - armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateSingleOutputMultipleInputsUint8) -{ - RefCreateSingleOutputMultipleInputsTest<RefSplitterWorkload, RefActivationWorkload, - armnn::DataType::QAsymmU8>(); -} - -template <typename ResizeBilinearWorkloadType, armnn::DataType DataType> -static void RefCreateResizeBilinearTest(DataLayout dataLayout) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateResizeBilinearWorkloadTest<ResizeBilinearWorkloadType, DataType>(factory, graph, dataLayout); - - TensorShape inputShape; - TensorShape outputShape; - - switch (dataLayout) - { - case DataLayout::NHWC: - inputShape = { 2, 4, 4, 3 }; - outputShape = { 2, 2, 2, 3 }; - break; - case DataLayout::NCHW: - default: - inputShape = { 2, 3, 4, 4 }; - outputShape = { 2, 3, 2, 2 }; - } - - // Checks that outputs and inputs are as we expect them (see definition of CreateResizeBilinearWorkloadTest). - CheckInputOutput(std::move(workload), - TensorInfo(inputShape, DataType), - TensorInfo(outputShape, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateResizeBilinearFloat32) -{ - RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateResizeBilinearFloat16) -{ - RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateResizeBilinearUint8) -{ - RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateResizeBilinearQuantisedAsymm16) -{ - RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateResizeBilinearFloat32Nhwc) -{ - RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC); -} - -template <typename BatchToSpaceNdWorkloadType, armnn::DataType DataType> -static void RefCreateBatchToSpaceNdTest() -{ - Graph graph; - RefWorkloadFactory factory; - - auto workload = CreateBatchToSpaceNdWorkloadTest<BatchToSpaceNdWorkloadType, DataType>(factory, graph); - - CheckInputOutput(std::move(workload), - TensorInfo({ 1, 1, 1, 1 }, DataType), - TensorInfo({ 1, 1, 1, 1 }, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateBatchToSpaceNdFloat32) -{ - RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateBatchToSpaceNdFloat16) -{ - RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float16>(); -} - -BOOST_AUTO_TEST_CASE(CreateBatchToSpaceNdUint8) -{ - RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateBatchToSpaceNdQSymm16) -{ - RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::QSymmS16>(); -} - -template <typename L2NormalizationWorkloadType, armnn::DataType DataType> -static void RefCreateL2NormalizationTest(DataLayout dataLayout) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = - CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout); - - TensorShape inputShape; - TensorShape outputShape; - - switch (dataLayout) - { - case DataLayout::NHWC: - inputShape = { 5, 50, 67, 20 }; - outputShape = { 5, 50, 67, 20 }; - break; - case DataLayout::NCHW: - default: - inputShape = { 5, 20, 50, 67 }; - outputShape = { 5, 20, 50, 67 }; - break; - } - - // Checks that outputs and inputs are as we expect them (see definition of CreateL2NormalizationWorkloadTest). - CheckInputOutput(std::move(workload), TensorInfo(inputShape, DataType), TensorInfo(outputShape, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat32) -{ - RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::Float32>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat32Nhwc) -{ - RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::Float32>(DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateL2NormalizationInt16) -{ - RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateL2NormalizationInt16Nhwc) -{ - RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(CreateL2NormalizationUint8) -{ - RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(CreateL2NormalizationUint8Nhwc) -{ - RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC); -} - -template <typename ReshapeWorkloadType, armnn::DataType DataType> -static void RefCreateReshapeWorkloadTest() -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateReshapeWorkloadTest<ReshapeWorkloadType, DataType>(factory, graph); - - // Checks that outputs and inputs are as we expect them (see definition of CreateReshapeWorkloadTest). - CheckInputOutput( - std::move(workload), - TensorInfo({ 4, 1 }, DataType), - TensorInfo({ 1, 4 }, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateReshapeWorkloadFloat32) -{ - RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateReshapeWorkloadQuantisedAsymm8) -{ - RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateReshapeWorkloadQuantisedSymm16) -{ - RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::QSymmS16>(); -} - -template <typename ConcatWorkloadType, armnn::DataType DataType> -static void RefCreateConcatWorkloadTest(const armnn::TensorShape& outputShape, - unsigned int concatAxis) -{ - Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis); - - CheckInputsOutput(std::move(workload), - TensorInfo({ 2, 3, 2, 5 }, DataType), - TensorInfo({ 2, 3, 2, 5 }, DataType), - TensorInfo(outputShape, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim0Float32Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim0Float16Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float16>({ 4, 3, 2, 5 }, 0); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim0Uint8Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim0Uint16Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QSymmS16>({ 4, 3, 2, 5 }, 0); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim1Float32Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim1Uint8Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim2Float32Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 3, 4, 5 }, 2); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim2Uint8Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 4, 5 }, 2); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim3Float32Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3); -} - -BOOST_AUTO_TEST_CASE(CreateConcatDim3Uint8Workload) -{ - RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3); -} - -template <typename ConstantWorkloadType, armnn::DataType DataType> -static void RefCreateConstantWorkloadTest(const armnn::TensorShape& outputShape) -{ - armnn::Graph graph; - RefWorkloadFactory factory = GetFactory(); - auto workload = CreateConstantWorkloadTest<ConstantWorkloadType, DataType>(factory, graph, outputShape); - - // Check output is as expected - auto queueDescriptor = workload->GetData(); - auto outputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]); - BOOST_TEST((outputHandle->GetTensorInfo() == TensorInfo(outputShape, DataType))); -} - -BOOST_AUTO_TEST_CASE(CreateConstantUint8Workload) -{ - RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }); -} - -BOOST_AUTO_TEST_CASE(CreateConstantInt16Workload) -{ - RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::QSymmS16>({ 2, 3, 2, 10 }); -} - -BOOST_AUTO_TEST_CASE(CreateConstantFloat32Workload) -{ - RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }); -} - -BOOST_AUTO_TEST_CASE(CreateConstantSigned32Workload) -{ - RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::Signed32>({ 2, 3, 2, 10 }); -} - -static void RefCreatePreluWorkloadTest(const armnn::TensorShape& inputShape, - const armnn::TensorShape& alphaShape, - const armnn::TensorShape& outputShape, - armnn::DataType dataType) -{ - armnn::Graph graph; - RefWorkloadFactory factory; - auto workload = CreatePreluWorkloadTest<RefPreluWorkload>(factory, - graph, - inputShape, - alphaShape, - outputShape, - dataType); - - // Check output is as expected - auto queueDescriptor = workload->GetData(); - auto outputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]); - BOOST_TEST((outputHandle->GetTensorInfo() == TensorInfo(outputShape, dataType))); -} - -BOOST_AUTO_TEST_CASE(CreatePreluFloat32Workload) -{ - RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::Float32); -} - -BOOST_AUTO_TEST_CASE(CreatePreluFloat16Workload) -{ - RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::Float16); -} - -BOOST_AUTO_TEST_CASE(CreatePreluUint8Workload) -{ - RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::QAsymmU8); -} - -BOOST_AUTO_TEST_CASE(CreatePreluInt16Workload) -{ - RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::QSymmS16); -} - -BOOST_AUTO_TEST_CASE(CreatePreluFloat32NoBroadcastWorkload) -{ - BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, - armnn::DataType::Float32), - armnn::InvalidArgumentException); -} - -BOOST_AUTO_TEST_CASE(CreatePreluFloat16NoBroadcastWorkload) -{ - BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, - armnn::DataType::Float16), - armnn::InvalidArgumentException); -} - -BOOST_AUTO_TEST_CASE(CreatePreluUint8NoBroadcastWorkload) -{ - BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, - armnn::DataType::QAsymmU8), - armnn::InvalidArgumentException); -} - -BOOST_AUTO_TEST_CASE(CreatePreluInt16NoBroadcastWorkload) -{ - BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, - armnn::DataType::QSymmS16), - armnn::InvalidArgumentException); -} - -template <typename SpaceToDepthWorkloadType, armnn::DataType DataType> -static void RefCreateSpaceToDepthWorkloadTest() -{ - Graph graph; - RefWorkloadFactory factory; - - auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph); - - CheckInputOutput(std::move(workload), - TensorInfo({ 1, 2, 2, 1 }, DataType), - TensorInfo({ 1, 1, 1, 4 }, DataType)); -} - -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthWorkloadFloat32) -{ - RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float32>(); -} - -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthWorkloadFloat16) -{ - RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float16>(); -} - -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthWorkloadQASymm8) -{ - RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::QAsymmU8>(); -} - -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthWorkloadQSymm16) -{ - RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::QSymmS16>(); -} - -template <armnn::DataType DataType> -static void RefCreateStackWorkloadTest(const armnn::TensorShape& inputShape, - const armnn::TensorShape& outputShape, - unsigned int axis, - unsigned int numInputs) -{ - armnn::Graph graph; - RefWorkloadFactory factory; - auto workload = CreateStackWorkloadTest<RefStackWorkload, DataType>(factory, - graph, - inputShape, - outputShape, - axis, - numInputs); - - // Check inputs and output are as expected - StackQueueDescriptor queueDescriptor = workload->GetData(); - for (unsigned int i = 0; i < numInputs; ++i) - { - auto inputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Inputs[i]); - BOOST_TEST((inputHandle->GetTensorInfo() == TensorInfo(inputShape, DataType))); - } - auto outputHandle = boost::polymorphic_downcast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]); - BOOST_TEST((outputHandle->GetTensorInfo() == TensorInfo(outputShape, DataType))); -} - -BOOST_AUTO_TEST_CASE(CreateStackFloat32Workload) -{ - RefCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2); -} - -BOOST_AUTO_TEST_CASE(CreateStackUint8Workload) -{ - RefCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2); -} - -BOOST_AUTO_TEST_CASE(CreateStackUint16Workload) -{ - RefCreateStackWorkloadTest<armnn::DataType::QSymmS16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2); -} - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefDetectionPostProcessTests.cpp b/src/backends/reference/test/RefDetectionPostProcessTests.cpp deleted file mode 100644 index fab6e00bad..0000000000 --- a/src/backends/reference/test/RefDetectionPostProcessTests.cpp +++ /dev/null @@ -1,204 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <reference/workloads/DetectionPostProcess.hpp> - -#include <armnn/Descriptors.hpp> -#include <armnn/Types.hpp> - -#include <boost/test/unit_test.hpp> - -BOOST_AUTO_TEST_SUITE(RefDetectionPostProcess) - -BOOST_AUTO_TEST_CASE(TopKSortTest) -{ - unsigned int k = 3; - unsigned int indices[8] = { 0, 1, 2, 3, 4, 5, 6, 7 }; - float values[8] = { 0, 7, 6, 5, 4, 3, 2, 500 }; - armnn::TopKSort(k, indices, values, 8); - BOOST_TEST(indices[0] == 7); - BOOST_TEST(indices[1] == 1); - BOOST_TEST(indices[2] == 2); -} - -BOOST_AUTO_TEST_CASE(FullTopKSortTest) -{ - unsigned int k = 8; - unsigned int indices[8] = { 0, 1, 2, 3, 4, 5, 6, 7 }; - float values[8] = { 0, 7, 6, 5, 4, 3, 2, 500 }; - armnn::TopKSort(k, indices, values, 8); - BOOST_TEST(indices[0] == 7); - BOOST_TEST(indices[1] == 1); - BOOST_TEST(indices[2] == 2); - BOOST_TEST(indices[3] == 3); - BOOST_TEST(indices[4] == 4); - BOOST_TEST(indices[5] == 5); - BOOST_TEST(indices[6] == 6); - BOOST_TEST(indices[7] == 0); -} - -BOOST_AUTO_TEST_CASE(IouTest) -{ - float boxI[4] = { 0.0f, 0.0f, 10.0f, 10.0f }; - float boxJ[4] = { 1.0f, 1.0f, 11.0f, 11.0f }; - float iou = armnn::IntersectionOverUnion(boxI, boxJ); - BOOST_TEST(iou == 0.68, boost::test_tools::tolerance(0.001)); -} - -BOOST_AUTO_TEST_CASE(NmsFunction) -{ - std::vector<float> boxCorners({ - 0.0f, 0.0f, 1.0f, 1.0f, - 0.0f, 0.1f, 1.0f, 1.1f, - 0.0f, -0.1f, 1.0f, 0.9f, - 0.0f, 10.0f, 1.0f, 11.0f, - 0.0f, 10.1f, 1.0f, 11.1f, - 0.0f, 100.0f, 1.0f, 101.0f - }); - - std::vector<float> scores({ 0.9f, 0.75f, 0.6f, 0.93f, 0.5f, 0.3f }); - - std::vector<unsigned int> result = - armnn::NonMaxSuppression(6, boxCorners, scores, 0.0, 3, 0.5); - - BOOST_TEST(result.size() == 3); - BOOST_TEST(result[0] == 3); - BOOST_TEST(result[1] == 0); - BOOST_TEST(result[2] == 5); -} - -void DetectionPostProcessTestImpl(bool useRegularNms, - const std::vector<float>& expectedDetectionBoxes, - const std::vector<float>& expectedDetectionClasses, - const std::vector<float>& expectedDetectionScores, - const std::vector<float>& expectedNumDetections) -{ - armnn::TensorInfo boxEncodingsInfo({ 1, 6, 4 }, armnn::DataType::Float32); - armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32); - armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32); - - armnn::TensorInfo detectionBoxesInfo({ 1, 3, 4 }, armnn::DataType::Float32); - armnn::TensorInfo detectionScoresInfo({ 1, 3 }, armnn::DataType::Float32); - armnn::TensorInfo detectionClassesInfo({ 1, 3 }, armnn::DataType::Float32); - armnn::TensorInfo numDetectionInfo({ 1 }, armnn::DataType::Float32); - - armnn::DetectionPostProcessDescriptor desc; - desc.m_UseRegularNms = useRegularNms; - desc.m_MaxDetections = 3; - desc.m_MaxClassesPerDetection = 1; - desc.m_DetectionsPerClass =1; - desc.m_NmsScoreThreshold = 0.0; - desc.m_NmsIouThreshold = 0.5; - desc.m_NumClasses = 2; - desc.m_ScaleY = 10.0; - desc.m_ScaleX = 10.0; - desc.m_ScaleH = 5.0; - desc.m_ScaleW = 5.0; - - std::vector<float> boxEncodings({ - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, -1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f - }); - - std::vector<float> scores({ - 0.0f, 0.9f, 0.8f, - 0.0f, 0.75f, 0.72f, - 0.0f, 0.6f, 0.5f, - 0.0f, 0.93f, 0.95f, - 0.0f, 0.5f, 0.4f, - 0.0f, 0.3f, 0.2f - }); - - std::vector<float> anchors({ - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 100.5f, 1.0f, 1.0f - }); - - auto boxEncodingsDecoder = armnn::MakeDecoder<float>(boxEncodingsInfo, boxEncodings.data()); - auto scoresDecoder = armnn::MakeDecoder<float>(scoresInfo, scores.data()); - auto anchorsDecoder = armnn::MakeDecoder<float>(anchorsInfo, anchors.data()); - - std::vector<float> detectionBoxes(detectionBoxesInfo.GetNumElements()); - std::vector<float> detectionScores(detectionScoresInfo.GetNumElements()); - std::vector<float> detectionClasses(detectionClassesInfo.GetNumElements()); - std::vector<float> numDetections(1); - - armnn::DetectionPostProcess(boxEncodingsInfo, - scoresInfo, - anchorsInfo, - detectionBoxesInfo, - detectionClassesInfo, - detectionScoresInfo, - numDetectionInfo, - desc, - *boxEncodingsDecoder, - *scoresDecoder, - *anchorsDecoder, - detectionBoxes.data(), - detectionClasses.data(), - detectionScores.data(), - numDetections.data()); - - BOOST_CHECK_EQUAL_COLLECTIONS(detectionBoxes.begin(), - detectionBoxes.end(), - expectedDetectionBoxes.begin(), - expectedDetectionBoxes.end()); - - BOOST_CHECK_EQUAL_COLLECTIONS(detectionScores.begin(), - detectionScores.end(), - expectedDetectionScores.begin(), - expectedDetectionScores.end()); - - BOOST_CHECK_EQUAL_COLLECTIONS(detectionClasses.begin(), - detectionClasses.end(), - expectedDetectionClasses.begin(), - expectedDetectionClasses.end()); - - BOOST_CHECK_EQUAL_COLLECTIONS(numDetections.begin(), - numDetections.end(), - expectedNumDetections.begin(), - expectedNumDetections.end()); -} - -BOOST_AUTO_TEST_CASE(RegularNmsDetectionPostProcess) -{ - std::vector<float> expectedDetectionBoxes({ - 0.0f, 10.0f, 1.0f, 11.0f, - 0.0f, 10.0f, 1.0f, 11.0f, - 0.0f, 0.0f, 0.0f, 0.0f - }); - - std::vector<float> expectedDetectionScores({ 0.95f, 0.93f, 0.0f }); - std::vector<float> expectedDetectionClasses({ 1.0f, 0.0f, 0.0f }); - std::vector<float> expectedNumDetections({ 2.0f }); - - DetectionPostProcessTestImpl(true, expectedDetectionBoxes, expectedDetectionClasses, - expectedDetectionScores, expectedNumDetections); -} - -BOOST_AUTO_TEST_CASE(FastNmsDetectionPostProcess) -{ - std::vector<float> expectedDetectionBoxes({ - 0.0f, 10.0f, 1.0f, 11.0f, - 0.0f, 0.0f, 1.0f, 1.0f, - 0.0f, 100.0f, 1.0f, 101.0f - }); - std::vector<float> expectedDetectionScores({ 0.95f, 0.9f, 0.3f }); - std::vector<float> expectedDetectionClasses({ 1.0f, 0.0f, 0.0f }); - std::vector<float> expectedNumDetections({ 3.0f }); - - DetectionPostProcessTestImpl(false, expectedDetectionBoxes, expectedDetectionClasses, - expectedDetectionScores, expectedNumDetections); -} - -BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp deleted file mode 100644 index 54a68810f6..0000000000 --- a/src/backends/reference/test/RefEndToEndTests.cpp +++ /dev/null @@ -1,1215 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <backendsCommon/test/EndToEndTestImpl.hpp> - -#include <backendsCommon/test/ArgMinMaxEndToEndTestImpl.hpp> -#include <backendsCommon/test/BatchToSpaceNdEndToEndTestImpl.hpp> -#include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp> -#include <backendsCommon/test/ConcatEndToEndTestImpl.hpp> -#include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp> -#include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp> -#include <backendsCommon/test/DetectionPostProcessEndToEndTestImpl.hpp> -#include <backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp> -#include <backendsCommon/test/GatherEndToEndTestImpl.hpp> -#include <backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp> -#include <backendsCommon/test/LogSoftmaxEndToEndTestImpl.hpp> -#include <backendsCommon/test/PreluEndToEndTestImpl.hpp> -#include <backendsCommon/test/ResizeEndToEndTestImpl.hpp> -#include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp> -#include <backendsCommon/test/SplitterEndToEndTestImpl.hpp> -#include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp> - -#include <boost/test/unit_test.hpp> -#include <boost/test/execution_monitor.hpp> - -BOOST_AUTO_TEST_SUITE(RefEndToEnd) - -std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::CpuRef}; - -// Abs -BOOST_AUTO_TEST_CASE(RefAbsEndToEndTestFloat32) -{ - std::vector<float> expectedOutput = - { - 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f, - 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f - }; - - ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, - UnaryOperation::Abs, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefAbsEndToEndTestUint8) -{ - // Note the expected output will be implicitly quantized by the below test function - std::vector<float> expectedOutput = - { - 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f, - 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f - }; - - ElementwiseUnarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, - UnaryOperation::Abs, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefAbsEndToEndTestInt16) -{ - // Note the expected output will be implicitly quantized by the below test function - std::vector<float> expectedOutput = - { - 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f, - 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f - }; - - ElementwiseUnarySimpleEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, - UnaryOperation::Abs, - expectedOutput); -} - -// Constant -BOOST_AUTO_TEST_CASE(ConstantUsage_Ref_Float32) -{ - BOOST_TEST(ConstantUsageFloat32Test(defaultBackends)); -} - -BOOST_AUTO_TEST_CASE(ConstantUsage_Ref_Uint8) -{ - BOOST_TEST(ConstantUsageUint8Test(defaultBackends)); -} - -BOOST_AUTO_TEST_CASE(Unsigned8) -{ - using namespace armnn; - - // Create runtime in which test will run - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - // Builds up the structure of the network. - armnn::INetworkPtr net(INetwork::Create()); - - IConnectableLayer* input = net->AddInputLayer(0, "input"); - IConnectableLayer* softmax = net->AddSoftmaxLayer(SoftmaxDescriptor(), "softmax"); - IConnectableLayer* output = net->AddOutputLayer(0, "output"); - - input->GetOutputSlot(0).Connect(softmax->GetInputSlot(0)); - softmax->GetOutputSlot(0).Connect(output->GetInputSlot(0)); - - // Sets the tensors in the network. - TensorInfo inputTensorInfo(TensorShape({1, 5}), DataType::QAsymmU8); - inputTensorInfo.SetQuantizationOffset(100); - inputTensorInfo.SetQuantizationScale(10000.0f); - input->GetOutputSlot(0).SetTensorInfo(inputTensorInfo); - - TensorInfo outputTensorInfo(TensorShape({1, 5}), DataType::QAsymmU8); - outputTensorInfo.SetQuantizationOffset(0); - outputTensorInfo.SetQuantizationScale(1.0f/255.0f); - softmax->GetOutputSlot(0).SetTensorInfo(outputTensorInfo); - - // optimize the network - IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec()); - - // Loads it into the runtime. - NetworkId netId; - auto error = runtime->LoadNetwork(netId, std::move(optNet)); - BOOST_TEST(error == Status::Success); - - // Creates structures for input & output. - std::vector<uint8_t> inputData - { - 1, 10, 3, 200, 5 // Some inputs - one of which is sufficiently larger than the others to saturate softmax. - }; - std::vector<uint8_t> outputData(5); - - armnn::InputTensors inputTensors - { - {0, armnn::ConstTensor(runtime->GetInputTensorInfo(netId, 0), inputData.data())} - }; - armnn::OutputTensors outputTensors - { - {0, armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())} - }; - - // Does the inference. - runtime->EnqueueWorkload(netId, inputTensors, outputTensors); - - // Checks the results. - BOOST_TEST(outputData[0] == 0); - BOOST_TEST(outputData[1] == 0); - BOOST_TEST(outputData[2] == 0); - BOOST_TEST(outputData[3] == 255); // softmax has been saturated. - BOOST_TEST(outputData[4] == 0); -} - -BOOST_AUTO_TEST_CASE(TrivialAdd) -{ - // This test was designed to match "AddTwo" in android nn/runtime/test/TestTrivialModel.cpp. - - using namespace armnn; - - // Create runtime in which test will run - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - // Builds up the structure of the network. - armnn::INetworkPtr net(INetwork::Create()); - - IConnectableLayer* input1 = net->AddInputLayer(0); - IConnectableLayer* input2 = net->AddInputLayer(1); - IConnectableLayer* add = net->AddAdditionLayer(); - IConnectableLayer* output = net->AddOutputLayer(0); - - input1->GetOutputSlot(0).Connect(add->GetInputSlot(0)); - input2->GetOutputSlot(0).Connect(add->GetInputSlot(1)); - add->GetOutputSlot(0).Connect(output->GetInputSlot(0)); - - // Sets the tensors in the network. - TensorInfo tensorInfo(TensorShape({3, 4}), DataType::Float32); - input1->GetOutputSlot(0).SetTensorInfo(tensorInfo); - input2->GetOutputSlot(0).SetTensorInfo(tensorInfo); - add->GetOutputSlot(0).SetTensorInfo(tensorInfo); - - // optimize the network - IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec()); - - // Loads it into the runtime. - NetworkId netId; - runtime->LoadNetwork(netId, std::move(optNet)); - - // Creates structures for input & output - matching android nn test. - std::vector<float> input1Data - { - 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f, 10.f, 11.f, 12.f - }; - std::vector<float> input2Data - { - 100.f, 200.f, 300.f, 400.f, 500.f, 600.f, 700.f, 800.f, 900.f, 1000.f, 1100.f, 1200.f - }; - std::vector<float> outputData(12); - - InputTensors inputTensors - { - {0,armnn::ConstTensor(runtime->GetInputTensorInfo(netId, 0), input1Data.data())}, - {1,armnn::ConstTensor(runtime->GetInputTensorInfo(netId, 0), input2Data.data())} - }; - OutputTensors outputTensors - { - {0,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())} - }; - - // Does the inference. - runtime->EnqueueWorkload(netId, inputTensors, outputTensors); - - // Checks the results - BOOST_TEST(outputData[0] == 101); - BOOST_TEST(outputData[1] == 202); - BOOST_TEST(outputData[2] == 303); - BOOST_TEST(outputData[3] == 404); - BOOST_TEST(outputData[4] == 505); - BOOST_TEST(outputData[5] == 606); - BOOST_TEST(outputData[6] == 707); - BOOST_TEST(outputData[7] == 808); - BOOST_TEST(outputData[8] == 909); - BOOST_TEST(outputData[9] == 1010); - BOOST_TEST(outputData[10] == 1111); - BOOST_TEST(outputData[11] == 1212); -} - -BOOST_AUTO_TEST_CASE(MultipleOutputs) -{ - using namespace armnn; - - // Create runtime in which test will run - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - // Builds up the structure of the network. - INetworkPtr net(INetwork::Create()); - - IConnectableLayer* input = net->AddInputLayer(0); - - // ReLu1 - ActivationDescriptor activation1Descriptor; - activation1Descriptor.m_Function = ActivationFunction::BoundedReLu; - activation1Descriptor.m_A = 1.f; - activation1Descriptor.m_B = -1.f; - IConnectableLayer* activation1 = net->AddActivationLayer(activation1Descriptor); - - // ReLu6 - ActivationDescriptor activation2Descriptor; - activation2Descriptor.m_Function = ActivationFunction::BoundedReLu; - activation2Descriptor.m_A = 6.0f; - IConnectableLayer* activation2 = net->AddActivationLayer(activation2Descriptor); - - // BoundedReLu(min=2, max=5) - ActivationDescriptor activation3Descriptor; - activation3Descriptor.m_Function = ActivationFunction::BoundedReLu; - activation3Descriptor.m_A = 5.0f; - activation3Descriptor.m_B = 2.0f; - IConnectableLayer* activation3 = net->AddActivationLayer(activation3Descriptor); - - IConnectableLayer* output1 = net->AddOutputLayer(0); - IConnectableLayer* output2 = net->AddOutputLayer(1); - IConnectableLayer* output3 = net->AddOutputLayer(2); - - input->GetOutputSlot(0).Connect(activation1->GetInputSlot(0)); - input->GetOutputSlot(0).Connect(activation2->GetInputSlot(0)); - input->GetOutputSlot(0).Connect(activation3->GetInputSlot(0)); - - activation1->GetOutputSlot(0).Connect(output1->GetInputSlot(0)); - activation2->GetOutputSlot(0).Connect(output2->GetInputSlot(0)); - activation3->GetOutputSlot(0).Connect(output3->GetInputSlot(0)); - - // Sets the tensors in the network. - TensorInfo tensorInfo(TensorShape({ 10 }), DataType::Float32); - input->GetOutputSlot(0).SetTensorInfo(tensorInfo); - activation1->GetOutputSlot(0).SetTensorInfo(tensorInfo); - activation2->GetOutputSlot(0).SetTensorInfo(tensorInfo); - activation3->GetOutputSlot(0).SetTensorInfo(tensorInfo); - - // optimize the network - IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec()); - - // Loads it into the runtime. - NetworkId netId; - runtime->LoadNetwork(netId, std::move(optNet)); - - // Creates structures for input & output. - const std::vector<float> inputData{ 3.f, 5.f, 2.f, 3.f, 7.f, 0.f, -2.f, -1.f, 3.f, 3.f }; - - std::vector<float> output1Data(inputData.size()); - std::vector<float> output2Data(inputData.size()); - std::vector<float> output3Data(inputData.size()); - - InputTensors inputTensors - { - {0,armnn::ConstTensor(runtime->GetInputTensorInfo(netId, 0), inputData.data())} - }; - OutputTensors outputTensors - { - {0,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), output1Data.data())}, - {1,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 1), output2Data.data())}, - {2,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 2), output3Data.data())} - }; - - // Does the inference. - runtime->EnqueueWorkload(netId, inputTensors, outputTensors); - - // Checks the results. - BOOST_TEST(output1Data == std::vector<float>({ 1.f, 1.f, 1.f, 1.f, 1.f, 0.f, -1.f, -1.f, 1.f, 1.f })); // ReLu1 - BOOST_TEST(output2Data == std::vector<float>({ 3.f, 5.f, 2.f, 3.f, 6.f, 0.f, 0.f, 0.f, 3.f, 3.f })); // ReLu6 - BOOST_TEST(output3Data == std::vector<float>({ 3.f, 5.f, 2.f, 3.f, 5.f, 2.f, 2.f, 2.f, 3.f, 3.f })); // [2, 5] -} - -BOOST_AUTO_TEST_CASE(TrivialMin) -{ - using namespace armnn; - - // Create runtime in which test will run - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - // Builds up the structure of the network. - armnn::INetworkPtr net(INetwork::Create()); - - IConnectableLayer* input1 = net->AddInputLayer(0); - IConnectableLayer* input2 = net->AddInputLayer(1); - IConnectableLayer* min = net->AddMinimumLayer(); - IConnectableLayer* output = net->AddOutputLayer(0); - - input1->GetOutputSlot(0).Connect(min->GetInputSlot(0)); - input2->GetOutputSlot(0).Connect(min->GetInputSlot(1)); - min->GetOutputSlot(0).Connect(output->GetInputSlot(0)); - - // Sets the tensors in the network. - TensorInfo tensorInfo(TensorShape({1, 1, 1, 4}), DataType::Float32); - input1->GetOutputSlot(0).SetTensorInfo(tensorInfo); - input2->GetOutputSlot(0).SetTensorInfo(tensorInfo); - min->GetOutputSlot(0).SetTensorInfo(tensorInfo); - - // optimize the network - IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec()); - - // Loads it into the runtime. - NetworkId netId; - runtime->LoadNetwork(netId, std::move(optNet)); - - // Creates structures for input & output - matching android nn test. - std::vector<float> input1Data - { - 1.0f, 2.0f, 3.0f, 4.0f - }; - std::vector<float> input2Data - { - 2.0f, 1.0f, 5.0f, 2.0f - }; - std::vector<float> outputData(4); - - InputTensors inputTensors - { - {0,armnn::ConstTensor(runtime->GetInputTensorInfo(netId, 0), input1Data.data())}, - {1,armnn::ConstTensor(runtime->GetInputTensorInfo(netId, 0), input2Data.data())} - }; - OutputTensors outputTensors - { - {0,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())} - }; - - // Does the inference. - runtime->EnqueueWorkload(netId, inputTensors, outputTensors); - - // Checks the results - BOOST_TEST(outputData[0] == 1); - BOOST_TEST(outputData[1] == 1); - BOOST_TEST(outputData[2] == 3); - BOOST_TEST(outputData[3] == 2); -} - -BOOST_AUTO_TEST_CASE(RefEqualSimpleEndToEndTest) -{ - const std::vector<uint8_t> expectedOutput({ 1, 1, 1, 1, 0, 0, 0, 0, - 0, 0, 0, 0, 1, 1, 1, 1 }); - - ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, - ComparisonOperation::Equal, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefGreaterSimpleEndToEndTest) -{ - const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0 }); - - ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, - ComparisonOperation::Greater, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefEqualSimpleEndToEndUint8Test) -{ - const std::vector<uint8_t> expectedOutput({ 1, 1, 1, 1, 0, 0, 0, 0, - 0, 0, 0, 0, 1, 1, 1, 1 }); - - ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, - ComparisonOperation::Equal, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefGreaterSimpleEndToEndUint8Test) -{ - const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0 }); - - ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, - ComparisonOperation::Greater, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefEqualBroadcastEndToEndTest) -{ - const std::vector<uint8_t> expectedOutput({ 1, 0, 1, 1, 0, 0, - 0, 0, 0, 0, 0, 0 }); - - ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends, - ComparisonOperation::Equal, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefGreaterBroadcastEndToEndTest) -{ - const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1, - 1, 1, 1, 1, 1, 1 }); - - ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends, - ComparisonOperation::Greater, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefEqualBroadcastEndToEndUint8Test) -{ - const std::vector<uint8_t > expectedOutput({ 1, 0, 1, 1, 0, 0, - 0, 0, 0, 0, 0, 0 }); - - ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, - ComparisonOperation::Equal, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefGreaterBroadcastEndToEndUint8Test) -{ - const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1, - 1, 1, 1, 1, 1, 1 }); - - ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, - ComparisonOperation::Greater, - expectedOutput); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndFloat32NHWCTest) -{ - BatchToSpaceNdEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndUint8NHWCTest) -{ - BatchToSpaceNdEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndQSymm16NHWCTest) -{ - BatchToSpaceNdEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndFloat32NCHWTest) -{ - BatchToSpaceNdEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndUint8NCHWTest) -{ - BatchToSpaceNdEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndQSymm16NCHWTest) -{ - BatchToSpaceNdEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexFloat32NHWCTest) -{ - BatchToSpaceNdComplexEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexUint8NHWCTest) -{ - BatchToSpaceNdComplexEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexQSymm16NHWCTest) -{ - BatchToSpaceNdComplexEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexFloat32NCHWTest) -{ - BatchToSpaceNdComplexEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexUint8NCHWTest) -{ - BatchToSpaceNdComplexEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexQSymm16NCHWTest) -{ - BatchToSpaceNdComplexEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim0Test) -{ - ConcatDim0EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim0Uint8Test) -{ - ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim1Test) -{ - ConcatDim1EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim1Uint8Test) -{ - ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim2Test) -{ - ConcatDim2EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim2Uint8Test) -{ - ConcatDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim3Test) -{ - ConcatDim3EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim3Uint8Test) -{ - ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefGatherFloatTest) -{ - GatherEndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefGatherUint8Test) -{ - GatherEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefGatherInt16Test) -{ - GatherEndToEnd<armnn::DataType::QSymmS16>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefGatherMultiDimFloatTest) -{ - GatherMultiDimEndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefGatherMultiDimUint8Test) -{ - GatherMultiDimEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefGatherMultiDimInt16Test) -{ - GatherMultiDimEndToEnd<armnn::DataType::QSymmS16>(defaultBackends); -} - -// DepthToSpace -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32) -{ - DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16) -{ - DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8) -{ - DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16) -{ - DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32) -{ - DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16) -{ - DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8) -{ - DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16) -{ - DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC); -} - -// Dequantize -BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest) -{ - DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetTest) -{ - DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleInt16Test) -{ - DequantizeEndToEndSimple<armnn::DataType::QSymmS16>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetInt16Test) -{ - DequantizeEndToEndOffset<armnn::DataType::QSymmS16>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefDetectionPostProcessRegularNmsTest) -{ - std::vector<float> boxEncodings({ - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, -1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f - }); - std::vector<float> scores({ - 0.0f, 0.9f, 0.8f, - 0.0f, 0.75f, 0.72f, - 0.0f, 0.6f, 0.5f, - 0.0f, 0.93f, 0.95f, - 0.0f, 0.5f, 0.4f, - 0.0f, 0.3f, 0.2f - }); - std::vector<float> anchors({ - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 100.5f, 1.0f, 1.0f - }); - DetectionPostProcessRegularNmsEndToEnd<armnn::DataType::Float32>(defaultBackends, boxEncodings, scores, anchors); -} - -inline void QuantizeData(uint8_t* quant, const float* dequant, const TensorInfo& info) -{ - for (size_t i = 0; i < info.GetNumElements(); i++) - { - quant[i] = armnn::Quantize<uint8_t>(dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset()); - } -} - -BOOST_AUTO_TEST_CASE(RefDetectionPostProcessRegularNmsUint8Test) -{ - armnn::TensorInfo boxEncodingsInfo({ 1, 6, 4 }, armnn::DataType::Float32); - armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32); - armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32); - - boxEncodingsInfo.SetQuantizationScale(1.0f); - boxEncodingsInfo.SetQuantizationOffset(1); - scoresInfo.SetQuantizationScale(0.01f); - scoresInfo.SetQuantizationOffset(0); - anchorsInfo.SetQuantizationScale(0.5f); - anchorsInfo.SetQuantizationOffset(0); - - std::vector<float> boxEncodings({ - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, -1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f - }); - std::vector<float> scores({ - 0.0f, 0.9f, 0.8f, - 0.0f, 0.75f, 0.72f, - 0.0f, 0.6f, 0.5f, - 0.0f, 0.93f, 0.95f, - 0.0f, 0.5f, 0.4f, - 0.0f, 0.3f, 0.2f - }); - std::vector<float> anchors({ - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 100.5f, 1.0f, 1.0f - }); - - std::vector<uint8_t> qBoxEncodings(boxEncodings.size(), 0); - std::vector<uint8_t> qScores(scores.size(), 0); - std::vector<uint8_t> qAnchors(anchors.size(), 0); - QuantizeData(qBoxEncodings.data(), boxEncodings.data(), boxEncodingsInfo); - QuantizeData(qScores.data(), scores.data(), scoresInfo); - QuantizeData(qAnchors.data(), anchors.data(), anchorsInfo); - DetectionPostProcessRegularNmsEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, qBoxEncodings, - qScores, qAnchors, - 1.0f, 1, 0.01f, 0, 0.5f, 0); -} - -BOOST_AUTO_TEST_CASE(RefDetectionPostProcessFastNmsTest) -{ - std::vector<float> boxEncodings({ - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, -1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f - }); - std::vector<float> scores({ - 0.0f, 0.9f, 0.8f, - 0.0f, 0.75f, 0.72f, - 0.0f, 0.6f, 0.5f, - 0.0f, 0.93f, 0.95f, - 0.0f, 0.5f, 0.4f, - 0.0f, 0.3f, 0.2f - }); - std::vector<float> anchors({ - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 100.5f, 1.0f, 1.0f - }); - DetectionPostProcessFastNmsEndToEnd<armnn::DataType::Float32>(defaultBackends, boxEncodings, scores, anchors); -} - -BOOST_AUTO_TEST_CASE(RefDetectionPostProcessFastNmsUint8Test) -{ - armnn::TensorInfo boxEncodingsInfo({ 1, 6, 4 }, armnn::DataType::Float32); - armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32); - armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32); - - boxEncodingsInfo.SetQuantizationScale(1.0f); - boxEncodingsInfo.SetQuantizationOffset(1); - scoresInfo.SetQuantizationScale(0.01f); - scoresInfo.SetQuantizationOffset(0); - anchorsInfo.SetQuantizationScale(0.5f); - anchorsInfo.SetQuantizationOffset(0); - - std::vector<float> boxEncodings({ - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, -1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f - }); - std::vector<float> scores({ - 0.0f, 0.9f, 0.8f, - 0.0f, 0.75f, 0.72f, - 0.0f, 0.6f, 0.5f, - 0.0f, 0.93f, 0.95f, - 0.0f, 0.5f, 0.4f, - 0.0f, 0.3f, 0.2f - }); - std::vector<float> anchors({ - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 0.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 10.5f, 1.0f, 1.0f, - 0.5f, 100.5f, 1.0f, 1.0f - }); - - std::vector<uint8_t> qBoxEncodings(boxEncodings.size(), 0); - std::vector<uint8_t> qScores(scores.size(), 0); - std::vector<uint8_t> qAnchors(anchors.size(), 0); - QuantizeData(qBoxEncodings.data(), boxEncodings.data(), boxEncodingsInfo); - QuantizeData(qScores.data(), scores.data(), scoresInfo); - QuantizeData(qAnchors.data(), anchors.data(), anchorsInfo); - DetectionPostProcessFastNmsEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, qBoxEncodings, - qScores, qAnchors, - 1.0f, 1, 0.01f, 0, 0.5f, 0); -} - -// LogSoftmax -BOOST_AUTO_TEST_CASE(RefLogSoftmaxEndToEndTest) -{ - LogSoftmaxEndToEndTest(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefPreluEndToEndTestFloat32) -{ - PreluEndToEndNegativeTest<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefPreluEndToEndTestUint8) -{ - PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefPreluEndToEndTestQSymm16) -{ - PreluEndToEndPositiveTest<armnn::DataType::QSymmS16>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSpaceToDepthNhwcEndToEndTest1) -{ - SpaceToDepthNhwcEndToEndTest1(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSpaceToDepthNchwEndToEndTest1) -{ - SpaceToDepthNchwEndToEndTest1(defaultBackends); - -} - -BOOST_AUTO_TEST_CASE(RefSpaceToDepthNhwcEndToEndTest2) -{ - SpaceToDepthNhwcEndToEndTest2(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSpaceToDepthNchwEndToEndTest2) -{ - SpaceToDepthNchwEndToEndTest2(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter1dEndToEndTest) -{ - Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter1dEndToEndUint8Test) -{ - Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter2dDim0EndToEndTest) -{ - Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter2dDim1EndToEndTest) -{ - Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter2dDim0EndToEndUint8Test) -{ - Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter2dDim1EndToEndUint8Test) -{ - Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter3dDim0EndToEndTest) -{ - Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter3dDim1EndToEndTest) -{ - Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter3dDim2EndToEndTest) -{ - Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter3dDim0EndToEndUint8Test) -{ - Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter3dDim1EndToEndUint8Test) -{ - Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter3dDim2EndToEndUint8Test) -{ - Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim0EndToEndTest) -{ - Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim1EndToEndTest) -{ - Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim2EndToEndTest) -{ - Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim3EndToEndTest) -{ - Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim0EndToEndUint8Test) -{ - Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim1EndToEndUint8Test) -{ - Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim2EndToEndUint8Test) -{ - Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefSplitter4dDim3EndToEndUint8Test) -{ - Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -// TransposeConvolution2d -BOOST_AUTO_TEST_CASE(RefTransposeConvolution2dEndToEndFloatNchwTest) -{ - TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>( - defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefTransposeConvolution2dEndToEndUint8NchwTest) -{ - TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>( - defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefTransposeConvolution2dEndToEndInt16NchwTest) -{ - TransposeConvolution2dEndToEnd<armnn::DataType::QSymmS16, armnn::DataType::Signed32>( - defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefTransposeConvolution2dEndToEndFloatNhwcTest) -{ - TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>( - defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefTransposeConvolution2dEndToEndUint8NhwcTest) -{ - TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>( - defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefTransposeConvolution2dEndToEndInt16NhwcTest) -{ - TransposeConvolution2dEndToEnd<armnn::DataType::QSymmS16, armnn::DataType::Signed32>( - defaultBackends, armnn::DataLayout::NHWC); -} - -// Resize Bilinear -BOOST_AUTO_TEST_CASE(RefResizeBilinearEndToEndFloatNchwTest) -{ - ResizeBilinearEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefResizeBilinearEndToEndUint8NchwTest) -{ - ResizeBilinearEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefResizeBilinearEndToEndInt16NchwTest) -{ - ResizeBilinearEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefResizeBilinearEndToEndFloatNhwcTest) -{ - ResizeBilinearEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefResizeBilinearEndToEndUint8NhwcTest) -{ - ResizeBilinearEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefResizeBilinearEndToEndInt16NhwcTest) -{ - ResizeBilinearEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC); -} - -// Resize NearestNeighbor -BOOST_AUTO_TEST_CASE(RefResizeNearestNeighborEndToEndFloatNchwTest) -{ - ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefResizeNearestNeighborEndToEndUint8NchwTest) -{ - ResizeNearestNeighborEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefResizeNearestNeighborEndToEndInt16NchwTest) -{ - ResizeNearestNeighborEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW); -} - -BOOST_AUTO_TEST_CASE(RefResizeNearestNeighborEndToEndFloatNhwcTest) -{ - ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefResizeNearestNeighborEndToEndUint8NhwcTest) -{ - ResizeNearestNeighborEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC); -} - -BOOST_AUTO_TEST_CASE(RefResizeNearestNeighborEndToEndInt16NhwcTest) -{ - ResizeNearestNeighborEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC); -} - -// InstanceNormalization -BOOST_AUTO_TEST_CASE(RefInstanceNormalizationNhwcEndToEndTest1) -{ - InstanceNormalizationNhwcEndToEndTest1(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefInstanceNormalizationNchwEndToEndTest1) -{ - InstanceNormalizationNchwEndToEndTest1(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefInstanceNormalizationNhwcEndToEndTest2) -{ - InstanceNormalizationNhwcEndToEndTest2(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefInstanceNormalizationNchwEndToEndTest2) -{ - InstanceNormalizationNchwEndToEndTest2(defaultBackends); -} - -// ArgMinMax -BOOST_AUTO_TEST_CASE(RefArgMaxSimpleTest) -{ - ArgMaxEndToEndSimple<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxSimpleUint8Test) -{ - ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinSimpleTest) -{ - ArgMinEndToEndSimple<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinSimpleUint8Test) -{ - ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis0Test) -{ - ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis0Uint8Test) -{ - ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis0Test) -{ - ArgMinAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis0Uint8Test) -{ - - ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis1Test) -{ - ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis1Uint8Test) -{ - ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis1Test) -{ - ArgMinAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis1Uint8Test) -{ - - ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis2Test) -{ - ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis2Uint8Test) -{ - ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis2Test) -{ - ArgMinAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis2Uint8Test) -{ - - ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis3Test) -{ - ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMaxAxis3Uint8Test) -{ - ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis3Test) -{ - ArgMinAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefArgMinAxis3Uint8Test) -{ - - ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends); -} - -#if !defined(__ANDROID__) -// Only run these tests on non Android platforms -BOOST_AUTO_TEST_CASE(RefImportNonAlignedPointerTest) -{ - ImportNonAlignedInputPointerTest(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefExportNonAlignedPointerTest) -{ - ExportNonAlignedOutputPointerTest(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefImportAlignedPointerTest) -{ - ImportAlignedPointerTest(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefImportOnlyWorkload) -{ - ImportOnlyWorkload(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefExportOnlyWorkload) -{ - ExportOnlyWorkload(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefImportAndExportWorkload) -{ - ImportAndExportWorkload(defaultBackends); -} - -BOOST_AUTO_TEST_CASE(RefExportOutputWithSeveralOutputSlotConnectionsTest) -{ - ExportOutputWithSeveralOutputSlotConnectionsTest(defaultBackends); -} - -#endif - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefJsonPrinterTests.cpp b/src/backends/reference/test/RefJsonPrinterTests.cpp deleted file mode 100644 index ff604a7ade..0000000000 --- a/src/backends/reference/test/RefJsonPrinterTests.cpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <armnn/BackendId.hpp> - -#include <backendsCommon/test/JsonPrinterTestImpl.hpp> - -#include <boost/test/unit_test.hpp> - -#include <vector> - -BOOST_AUTO_TEST_SUITE(RefJsonPrinter) - -BOOST_AUTO_TEST_CASE(SoftmaxProfilerJsonPrinterCpuRefTest) -{ - std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; - RunSoftmaxProfilerJsonPrinterTest(backends); -} - -BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file diff --git a/src/backends/reference/test/RefLayerSupportTests.cpp b/src/backends/reference/test/RefLayerSupportTests.cpp deleted file mode 100644 index f0c49aceb0..0000000000 --- a/src/backends/reference/test/RefLayerSupportTests.cpp +++ /dev/null @@ -1,169 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <layers/ConvertFp16ToFp32Layer.hpp> -#include <layers/ConvertFp32ToFp16Layer.hpp> -#include <test/TensorHelpers.hpp> - -#include <backendsCommon/CpuTensorHandle.hpp> -#include <reference/RefWorkloadFactory.hpp> -#include <reference/RefLayerSupport.hpp> -#include <backendsCommon/test/LayerTests.hpp> -#include <backendsCommon/test/IsLayerSupportedTestImpl.hpp> - -#include <boost/test/unit_test.hpp> -#include <boost/algorithm/string/trim.hpp> - -#include <string> - -namespace -{ - -bool LayerTypeMatchesTest() -{ - return LayerTypeMatchesTestImpl<armnn::LayerType::FirstLayer>(Tag<armnn::LayerType::FirstLayer>()); -}; - -} // anonymous namespace - -BOOST_AUTO_TEST_SUITE(RefLayerSupported) - -BOOST_AUTO_TEST_CASE(IsLayerSupportedLayerTypeMatches) -{ - LayerTypeMatchesTest(); -} -BOOST_AUTO_TEST_CASE(IsLayerSupportedReferenceAddition) -{ - armnn::TensorShape shape0 = {1,1,3,4}; - armnn::TensorShape shape1 = {4}; - armnn::TensorShape outShape = {1,1,3,4}; - armnn::TensorInfo in0(shape0, armnn::DataType::Float32); - armnn::TensorInfo in1(shape1, armnn::DataType::Float32); - armnn::TensorInfo out(outShape, armnn::DataType::Float32); - - armnn::RefLayerSupport supportChecker; - std::string reasonNotSupported; - BOOST_CHECK(supportChecker.IsAdditionSupported(in0, in1, out, reasonNotSupported)); -} - -BOOST_AUTO_TEST_CASE(IsLayerSupportedFloat16Reference) -{ - armnn::RefWorkloadFactory factory; - IsLayerSupportedTests<armnn::RefWorkloadFactory, armnn::DataType::Float16>(&factory); -} - -BOOST_AUTO_TEST_CASE(IsLayerSupportedFloat32Reference) -{ - armnn::RefWorkloadFactory factory; - IsLayerSupportedTests<armnn::RefWorkloadFactory, armnn::DataType::Float32>(&factory); -} - -BOOST_AUTO_TEST_CASE(IsLayerSupportedUint8Reference) -{ - armnn::RefWorkloadFactory factory; - IsLayerSupportedTests<armnn::RefWorkloadFactory, armnn::DataType::QAsymmU8>(&factory); -} - -BOOST_AUTO_TEST_CASE(IsLayerSupportedInt8Reference) -{ - armnn::RefWorkloadFactory factory; - IsLayerSupportedTests<armnn::RefWorkloadFactory, armnn::DataType::QSymmS8>(&factory); -} - -BOOST_AUTO_TEST_CASE(IsLayerSupportedInt16Reference) -{ - armnn::RefWorkloadFactory factory; - IsLayerSupportedTests<armnn::RefWorkloadFactory, armnn::DataType::QSymmS16>(&factory); -} - -BOOST_AUTO_TEST_CASE(IsConvertFp16ToFp32SupportedReference) -{ - std::string reasonIfUnsupported; - - bool result = IsConvertLayerSupportedTests<armnn::RefWorkloadFactory, armnn::ConvertFp16ToFp32Layer, - armnn::DataType::Float16, armnn::DataType::Float32>(reasonIfUnsupported); - - BOOST_CHECK(result); -} - -BOOST_AUTO_TEST_CASE(IsConvertFp16ToFp32SupportedFp32InputReference) -{ - std::string reasonIfUnsupported; - - bool result = IsConvertLayerSupportedTests<armnn::RefWorkloadFactory, armnn::ConvertFp16ToFp32Layer, - armnn::DataType::Float32, armnn::DataType::Float32>(reasonIfUnsupported); - - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Layer is not supported with float32 data type input"); -} - -BOOST_AUTO_TEST_CASE(IsConvertFp16ToFp32SupportedFp16OutputReference) -{ - std::string reasonIfUnsupported; - - bool result = IsConvertLayerSupportedTests<armnn::RefWorkloadFactory, armnn::ConvertFp16ToFp32Layer, - armnn::DataType::Float16, armnn::DataType::Float16>(reasonIfUnsupported); - - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Layer is not supported with float16 data type output"); -} - -BOOST_AUTO_TEST_CASE(IsConvertFp32ToFp16SupportedReference) -{ - std::string reasonIfUnsupported; - - bool result = IsConvertLayerSupportedTests<armnn::RefWorkloadFactory, armnn::ConvertFp32ToFp16Layer, - armnn::DataType::Float32, armnn::DataType::Float16>(reasonIfUnsupported); - - BOOST_CHECK(result); -} - -BOOST_AUTO_TEST_CASE(IsConvertFp32ToFp16SupportedFp16InputReference) -{ - std::string reasonIfUnsupported; - - bool result = IsConvertLayerSupportedTests<armnn::RefWorkloadFactory, armnn::ConvertFp32ToFp16Layer, - armnn::DataType::Float16, armnn::DataType::Float16>(reasonIfUnsupported); - - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Layer is not supported with float16 data type input"); -} - -BOOST_AUTO_TEST_CASE(IsConvertFp32ToFp16SupportedFp32OutputReference) -{ - std::string reasonIfUnsupported; - - bool result = IsConvertLayerSupportedTests<armnn::RefWorkloadFactory, armnn::ConvertFp32ToFp16Layer, - armnn::DataType::Float32, armnn::DataType::Float32>(reasonIfUnsupported); - - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Layer is not supported with float32 data type output"); -} - -BOOST_AUTO_TEST_CASE(IsLayerSupportedMeanDimensionsReference) -{ - std::string reasonIfUnsupported; - - bool result = IsMeanLayerSupportedTests<armnn::RefWorkloadFactory, - armnn::DataType::Float32, armnn::DataType::Float32>(reasonIfUnsupported); - - BOOST_CHECK(result); -} - -BOOST_AUTO_TEST_CASE(IsLayerNotSupportedMeanDimensionsReference) -{ - std::string reasonIfUnsupported; - - bool result = IsMeanLayerNotSupportedTests<armnn::RefWorkloadFactory, - armnn::DataType::Float32, armnn::DataType::Float32>(reasonIfUnsupported); - - BOOST_CHECK(!result); - - boost::algorithm::trim(reasonIfUnsupported); - BOOST_CHECK_EQUAL(reasonIfUnsupported, - "Reference Mean: Expected 4 dimensions but got 2 dimensions instead, for the 'output' tensor."); -} - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp deleted file mode 100644 index 99468e0006..0000000000 --- a/src/backends/reference/test/RefLayerTests.cpp +++ /dev/null @@ -1,1645 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefWorkloadFactoryHelper.hpp" - -#include <backendsCommon/test/LayerTests.hpp> - -#include <reference/RefWorkloadFactory.hpp> - -#include <test/TensorHelpers.hpp> -#include <test/UnitTests.hpp> - -#include <boost/test/unit_test.hpp> - -BOOST_AUTO_TEST_SUITE(Compute_Reference) - -using namespace armnn; - -using FactoryType = RefWorkloadFactory; - -// ============================================================================ -// UNIT tests - -// Convolution -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x5, SimpleConvolution2d3x5Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x5Uint8, SimpleConvolution2d3x5Uint8Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x5Nhwc, SimpleConvolution2d3x5Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x5Uint8Nhwc, SimpleConvolution2d3x5Uint8Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x5QSymm16, SimpleConvolution2d3x5QSymm16Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x5QSymm16Nhwc, SimpleConvolution2d3x5QSymm16Test, true, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2d, SimpleConvolution2d3x5Test, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolutionUint8, SimpleConvolution2d3x5Uint8Test, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dNhwc, SimpleConvolution2d3x5Test, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolutionUint8Nhwc, SimpleConvolution2d3x5Uint8Test, false, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(SimpleConvolution1d, Convolution1dTest, true) -ARMNN_AUTO_TEST_CASE(SimpleConvolution1dUint8, Convolution1dUint8Test, true) - -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3, SimpleConvolution2d3x3Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3Uint8, SimpleConvolution2d3x3Uint8Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3QSymm16, SimpleConvolution2d3x3QSymm16Test, true, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3Nhwc, SimpleConvolution2d3x3Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3Uint8Nhwc, SimpleConvolution2d3x3Uint8Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3QSymm16Nhwc, SimpleConvolution2d3x3QSymm16Test, true, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dSquare, SimpleConvolution2d3x3Test, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dSquareNhwc, SimpleConvolution2d3x3Test, false, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dSquareStride2x2Nhwc, - SimpleConvolution2d3x3Stride2x2Test, - false, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(SimpleConvolution2dAsymmetricPaddingLargerThanHalfKernelSize, - Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2dAsymmetricPadding, Convolution2dAsymmetricPaddingTest, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(SimpleConvolution2dAsymmetricPaddingLargerThanHalfKernelSizeNhwc, - Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2dAsymmetricPaddingNhwc, - Convolution2dAsymmetricPaddingTest, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(SimpleConvolution2dSquareNhwc, SimpleConvolution2d3x3NhwcTest, false) - -ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3, - Convolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3Nhwc, - Convolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3Uint8, - Convolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3NhwcUint8, - Convolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3Int16, - Convolution2d3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3NhwcInt16, - Convolution2d3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3, - Convolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3Nhwc, - Convolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3Uint8, - Convolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3NhwcUint8, - Convolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3Int16, - Convolution2d2x3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3NhwcInt16, - Convolution2d2x3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Nhwc, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Uint8, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3NhwcUint8, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Int16, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3NhwcInt16, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(Convolution2dPerAxisQuantTestNchw, Convolution2dPerAxisQuantTest, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(Convolution2dPerAxisQuantTestNhwc, Convolution2dPerAxisQuantTest, DataLayout::NHWC); - -// Depthwise Convolution -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d, DepthwiseConvolution2dTest, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dUint8, DepthwiseConvolution2dUint8Test, true, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2d, DepthwiseConvolution2dTest, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dUint8, - DepthwiseConvolution2dUint8Test, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dQSymm16, DepthwiseConvolution2dInt16Test, true, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dNhwc, DepthwiseConvolution2dTest, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dUint8Nhwc, DepthwiseConvolution2dUint8Test, true, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dNhwc, DepthwiseConvolution2dTest, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dUint8Nhwc, - DepthwiseConvolution2dUint8Test, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthNhwc, DepthwiseConvolution2dDepthNhwcTest, false) -ARMNN_AUTO_TEST_CASE(SimpleDepthwiseConvolution2d3x3Dilation3x3Nhwc, - SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTest) - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d3x3Dilation3x3, - DepthwiseConvolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d3x3Dilation3x3Nhwc, - DepthwiseConvolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d3x3Dilation3x3Uint8, - DepthwiseConvolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d3x3Dilation3x3NhwcUint8, - DepthwiseConvolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d3x3Dilation3x3Int16, - DepthwiseConvolution2d3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d3x3Dilation3x3NhwcInt16, - DepthwiseConvolution2d3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d2x3x3Dilation3x3, - DepthwiseConvolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d2x3x3Dilation3x3Nhwc, - DepthwiseConvolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d2x3x3Dilation3x3Uint8, - DepthwiseConvolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d2x3x3Dilation3x3NhwcUint8, - DepthwiseConvolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d2x3x3Dilation3x3Int16, - DepthwiseConvolution2d2x3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2d2x3x3Dilation3x3NhwcInt16, - DepthwiseConvolution2d2x3x3Dilation3x3Test<DataType::QSymmS16, DataType::Signed32>, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dMult4, - DepthwiseConvolution2dMult4Test<armnn::DataType::Float32, armnn::DataType::Float32>, - false, - armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dMult2, - DepthwiseConvolution2dMult2Test<armnn::DataType::Float32, armnn::DataType::Float32>, - false, - armnn::DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1, - DepthwiseConvolution2dDepthMul1Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1Uint8, - DepthwiseConvolution2dDepthMul1Uint8Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1Int16, - DepthwiseConvolution2dDepthMul1Int16Test, true, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1, - DepthwiseConvolution2dDepthMul1Test, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1Uint8, - DepthwiseConvolution2dDepthMul1Uint8Test, false, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1Nhwc, - DepthwiseConvolution2dDepthMul1Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1Uint8Nhwc, - DepthwiseConvolution2dDepthMul1Uint8Test, true, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1Nhwc, - DepthwiseConvolution2dDepthMul1Test, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1Uint8Nhwc, - DepthwiseConvolution2dDepthMul1Uint8Test, false, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dAsymmetric, - DepthwiseConvolution2dAsymmetricTest, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dAsymmetric, - DepthwiseConvolution2dAsymmetricTest, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dAsymmetricNhwc, - DepthwiseConvolution2dAsymmetricTest, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dAsymmetricNhwc, - DepthwiseConvolution2dAsymmetricTest, false, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul64, DepthwiseConvolution2dDepthMul64Test); - -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dPerAxisQuantTestNchw, DepthwiseConvolution2dPerAxisQuantTest, - DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dPerAxisQuantTestNhwc, DepthwiseConvolution2dPerAxisQuantTest, - DataLayout::NHWC); - -// Pooling -//MaxPooling -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize2x2Stride2x2, SimpleMaxPooling2dSize2x2Stride2x2Test, false) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize2x2Stride2x2Uint8, SimpleMaxPooling2dSize2x2Stride2x2Uint8Test, false) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize2x2Stride2x2Int16, SimpleMaxPooling2dSize2x2Stride2x2Int16Test, false) - -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize3x3Stride2x4, SimpleMaxPooling2dSize3x3Stride2x4Test, false) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize3x3Stride2x4Uint8, SimpleMaxPooling2dSize3x3Stride2x4Uint8Test, false) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize3x3Stride2x4Int16, SimpleMaxPooling2dSize3x3Stride2x4Int16Test, false) - -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2d, SimpleMaxPooling2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dNhwc, SimpleMaxPooling2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dUint8, SimpleMaxPooling2dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dInt16, SimpleMaxPooling2dInt16Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dUint8Nhwc, SimpleMaxPooling2dUint8Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dInt16Nhwc, SimpleMaxPooling2dInt16Test, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleMaxPooling2d, IgnorePaddingSimpleMaxPooling2dTest) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleMaxPooling2dUint8, IgnorePaddingSimpleMaxPooling2dUint8Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleMaxPooling2dInt16, IgnorePaddingSimpleMaxPooling2dInt16Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingMaxPooling2dSize3, IgnorePaddingMaxPooling2dSize3Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingMaxPooling2dSize3Uint8, IgnorePaddingMaxPooling2dSize3Uint8Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingMaxPooling2dSize3Int16, IgnorePaddingMaxPooling2dSize3Int16Test) - -//AveragePooling -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2d, SimpleAveragePooling2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dNhwc, SimpleAveragePooling2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dUint8, SimpleAveragePooling2dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dInt16, SimpleAveragePooling2dInt16Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dUint8Nhwc, SimpleAveragePooling2dUint8Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dInt16Nhwc, SimpleAveragePooling2dInt16Test, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleAveragePooling2d, IgnorePaddingSimpleAveragePooling2dTest) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleAveragePooling2dUint8, IgnorePaddingSimpleAveragePooling2dUint8Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleAveragePooling2dInt16, IgnorePaddingSimpleAveragePooling2dInt16Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleAveragePooling2dNoPadding, IgnorePaddingSimpleAveragePooling2dNoPaddingTest) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleAveragePooling2dNoPaddingUint8, - IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleAveragePooling2dNoPaddingInt16, - IgnorePaddingSimpleAveragePooling2dNoPaddingInt16Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingAveragePooling2dSize3, IgnorePaddingAveragePooling2dSize3Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingAveragePooling2dSize3Uint8, IgnorePaddingAveragePooling2dSize3Uint8Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingAveragePooling2dSize3Int16, IgnorePaddingAveragePooling2dSize3Int16Test) - -ARMNN_AUTO_TEST_CASE(IgnorePaddingAveragePooling2dSize3x2Stride2x2, - IgnorePaddingAveragePooling2dSize3x2Stride2x2Test, false) -ARMNN_AUTO_TEST_CASE(IgnorePaddingAveragePooling2dSize3x2Stride2x2NoPadding, - IgnorePaddingAveragePooling2dSize3x2Stride2x2Test, true) - -ARMNN_AUTO_TEST_CASE(LargeTensorsAveragePooling2d, LargeTensorsAveragePooling2dTest) -ARMNN_AUTO_TEST_CASE(LargeTensorsAveragePooling2dUint8, LargeTensorsAveragePooling2dUint8Test) -ARMNN_AUTO_TEST_CASE(LargeTensorsAveragePooling2dInt16, LargeTensorsAveragePooling2dInt16Test) - -//L2Pooling -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleL2Pooling2d, IgnorePaddingSimpleL2Pooling2dTest) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleL2Pooling2dUint8, IgnorePaddingSimpleL2Pooling2dUint8Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingSimpleL2Pooling2dInt16, IgnorePaddingSimpleL2Pooling2dInt16Test) - -ARMNN_AUTO_TEST_CASE(IgnorePaddingL2Pooling2dSize3, IgnorePaddingL2Pooling2dSize3Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingL2Pooling2dSize3Uint8, IgnorePaddingL2Pooling2dSize3Uint8Test) -ARMNN_AUTO_TEST_CASE(IgnorePaddingL2Pooling2dSize3Int16, IgnorePaddingL2Pooling2dSize3Int16Test) - -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2d, SimpleL2Pooling2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2dNhwc, SimpleL2Pooling2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2dUint8, SimpleL2Pooling2dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2dInt16, SimpleL2Pooling2dInt16Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2dNhwcUint8, SimpleL2Pooling2dUint8Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2dNhwcInt16, SimpleL2Pooling2dInt16Test, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(L2Pooling2dSize7, L2Pooling2dSize7Test) -ARMNN_AUTO_TEST_CASE(L2Pooling2dSize7Uint8, L2Pooling2dSize7Uint8Test) -ARMNN_AUTO_TEST_CASE(L2Pooling2dSize7Int16, L2Pooling2dSize7Int16Test) - -//NonSquarePooling -ARMNN_AUTO_TEST_CASE(AsymmNonSquarePooling2d, AsymmetricNonSquarePooling2dTest) -ARMNN_AUTO_TEST_CASE(AsymmNonSquarePooling2dUint8, AsymmetricNonSquarePooling2dUint8Test) -ARMNN_AUTO_TEST_CASE(AsymmNonSquarePooling2dInt16, AsymmetricNonSquarePooling2dInt16Test) - - -// Linear Activation -ARMNN_AUTO_TEST_CASE(ConstantLinearActivation, ConstantLinearActivationTest) -ARMNN_AUTO_TEST_CASE(ConstantLinearActivationUint8, ConstantLinearActivationUint8Test) -ARMNN_AUTO_TEST_CASE(ConstantLinearActivationInt16, ConstantLinearActivationInt16Test) - -// InstanceNormalization -ARMNN_AUTO_TEST_CASE(InstanceNormFloat32Nchw, InstanceNormFloat32Test, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(InstanceNormFloat16Nchw, InstanceNormFloat16Test, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(InstanceNormFloat32Nhwc, InstanceNormFloat32Test, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(InstanceNormFloat16Nhwc, InstanceNormFloat16Test, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(InstanceNormFloat32Nchw2, InstanceNormFloat32Test2, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(InstanceNormFloat16Nchw2, InstanceNormFloat16Test2, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(InstanceNormFloat32Nhwc2, InstanceNormFloat32Test2, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(InstanceNormFloat16Nhwc2, InstanceNormFloat16Test2, DataLayout::NHWC); - -// Normalization -ARMNN_AUTO_TEST_CASE(SimpleNormalizationAcross, SimpleNormalizationAcrossTest) -ARMNN_AUTO_TEST_CASE(SimpleNormalizationWithin, SimpleNormalizationWithinTest) -ARMNN_AUTO_TEST_CASE(SimpleNormalizationAcrossNhwc, SimpleNormalizationAcrossNhwcTest) - -// Softmax -ARMNN_AUTO_TEST_CASE(SimpleSoftmaxBeta1, SimpleSoftmaxTest, 1.0f) -ARMNN_AUTO_TEST_CASE(SimpleSoftmaxBeta2, SimpleSoftmaxTest, 2.0f) -ARMNN_AUTO_TEST_CASE(SimpleSoftmaxBeta1Uint8, SimpleSoftmaxUint8Test, 1.0f) -ARMNN_AUTO_TEST_CASE(SimpleSoftmaxBeta2Uint8, SimpleSoftmaxUint8Test, 2.0f) - -ARMNN_AUTO_TEST_CASE(Simple3dSoftmax, Simple3dSoftmaxTest, 1.0f) -ARMNN_AUTO_TEST_CASE(Simple3dSoftmaxUint8, Simple3dSoftmaxUint8Test, 1.0f) - -ARMNN_AUTO_TEST_CASE(Simple4dSoftmax, Simple4dSoftmaxTest, 1.0f) -ARMNN_AUTO_TEST_CASE(Simple4dSoftmaxUint8, Simple4dSoftmaxUint8Test, 1.0f) - -ARMNN_AUTO_TEST_CASE(SimpleSoftmaxFloat16, SimpleSoftmaxFloat16Test, 1.0f) -ARMNN_AUTO_TEST_CASE(Simple3dSoftmaxFloat16, Simple3dSoftmaxFloat16Test, 1.0f) -ARMNN_AUTO_TEST_CASE(Simple4dSoftmaxFloat16, Simple4dSoftmaxFloat16Test, 1.0f) - -ARMNN_AUTO_TEST_CASE(SimpleSoftmaxUint16, SimpleSoftmaxUint16Test, 1.0f) -ARMNN_AUTO_TEST_CASE(Simple3dSoftmaxUint16, Simple3dSoftmaxUint16Test, 1.0f) -ARMNN_AUTO_TEST_CASE(Simple4dSoftmaxUint16, Simple4dSoftmaxUint16Test, 1.0f) - -ARMNN_AUTO_TEST_CASE(Simple2dAxis0Softmax, SimpleAxisSoftmaxTest, 1.0f, 0) -ARMNN_AUTO_TEST_CASE(Simple2dAxis1Softmax, SimpleAxisSoftmaxTest, 1.0f, 1) - -ARMNN_AUTO_TEST_CASE(Simple2dAxis0NegSoftmax, SimpleAxisSoftmaxTest, 1.0f, -2) -ARMNN_AUTO_TEST_CASE(Simple2dAxis1NegSoftmax, SimpleAxisSoftmaxTest, 1.0f, -1) - -ARMNN_AUTO_TEST_CASE(Simple3dAxis0Softmax, Simple3dAxisSoftmaxTest, 1.0f, 0) -ARMNN_AUTO_TEST_CASE(Simple3dAxis1Softmax, Simple3dAxisSoftmaxTest, 1.0f, 1) -ARMNN_AUTO_TEST_CASE(Simple3dAxis2Softmax, Simple3dAxisSoftmaxTest, 1.0f, 2) - -ARMNN_AUTO_TEST_CASE(Simple3dAxis0NegSoftmax, Simple3dAxisSoftmaxTest, 1.0f, -3) -ARMNN_AUTO_TEST_CASE(Simple3dAxis1NegSoftmax, Simple3dAxisSoftmaxTest, 1.0f, -2) -ARMNN_AUTO_TEST_CASE(Simple3dAxis2NegSoftmax, Simple3dAxisSoftmaxTest, 1.0f, -1) - -ARMNN_AUTO_TEST_CASE(Simple4dAxis0Softmax, Simple4dAxisSoftmaxTest, 1.0f, 0) -ARMNN_AUTO_TEST_CASE(Simple4dAxis1Softmax, Simple4dAxisSoftmaxTest, 1.0f, 1) -ARMNN_AUTO_TEST_CASE(Simple4dAxis2Softmax, Simple4dAxisSoftmaxTest, 1.0f, 2) -ARMNN_AUTO_TEST_CASE(Simple4dAxis3Softmax, Simple4dAxisSoftmaxTest, 1.0f, 3) - -ARMNN_AUTO_TEST_CASE(Simple4dAxis0NegSoftmax, Simple4dAxisSoftmaxTest, 1.0f, -4) -ARMNN_AUTO_TEST_CASE(Simple4dAxis1NegSoftmax, Simple4dAxisSoftmaxTest, 1.0f, -3) -ARMNN_AUTO_TEST_CASE(Simple4dAxis2NegSoftmax, Simple4dAxisSoftmaxTest, 1.0f, -2) -ARMNN_AUTO_TEST_CASE(Simple4dAxis3NegSoftmax, Simple4dAxisSoftmaxTest, 1.0f, -1) - -// Sigmoid Activation -ARMNN_AUTO_TEST_CASE(SimpleSigmoid, SimpleSigmoidTest) -ARMNN_AUTO_TEST_CASE(SimpleSigmoidUint8, SimpleSigmoidUint8Test) -ARMNN_AUTO_TEST_CASE(SimpleSigmoidInt16, SimpleSigmoidInt16Test) - -// BoundedReLU Activation -ARMNN_AUTO_TEST_CASE(ReLu1, BoundedReLuUpperAndLowerBoundTest) -ARMNN_AUTO_TEST_CASE(ReLu6, BoundedReLuUpperBoundOnlyTest) -ARMNN_AUTO_TEST_CASE(ReLu1Uint8, BoundedReLuUint8UpperAndLowerBoundTest) -ARMNN_AUTO_TEST_CASE(ReLu6Uint8, BoundedReLuUint8UpperBoundOnlyTest) -ARMNN_AUTO_TEST_CASE(BoundedReLuInt16, BoundedReLuInt16Test) - -// ReLU Activation -ARMNN_AUTO_TEST_CASE(ReLu, ReLuTest) -ARMNN_AUTO_TEST_CASE(ReLuUint8, ReLuUint8Test) -ARMNN_AUTO_TEST_CASE(ReLuInt16, ReLuInt16Test) - -// SoftReLU Activation -ARMNN_AUTO_TEST_CASE(SoftReLu, SoftReLuTest) -ARMNN_AUTO_TEST_CASE(SoftReLuUint8, SoftReLuUint8Test) -ARMNN_AUTO_TEST_CASE(SoftReLuInt16, SoftReLuInt16Test) - - -// LeakyReLU Activation -ARMNN_AUTO_TEST_CASE(LeakyReLu, LeakyReLuTest) -ARMNN_AUTO_TEST_CASE(LeakyReLuUint8, LeakyReLuUint8Test) -ARMNN_AUTO_TEST_CASE(LeakyReLuInt16, LeakyReLuInt16Test) - -// Abs Activation -ARMNN_AUTO_TEST_CASE(Abs, AbsTest) -ARMNN_AUTO_TEST_CASE(AbsUint8, AbsUint8Test) -ARMNN_AUTO_TEST_CASE(AbsInt16, AbsInt16Test) - -// Sqrt Activation -ARMNN_AUTO_TEST_CASE(Sqrt, SqrtTest) -ARMNN_AUTO_TEST_CASE(SqrtNN, SqrtNNTest) -ARMNN_AUTO_TEST_CASE(SqrtUint8, SqrtUint8Test) -ARMNN_AUTO_TEST_CASE(SqrtInt16, SqrtInt16Test) - -// Square Activation -ARMNN_AUTO_TEST_CASE(Square, SquareTest) -ARMNN_AUTO_TEST_CASE(SquareUint8, SquareUint8Test) -ARMNN_AUTO_TEST_CASE(SquareInt16, SquareInt16Test) - -// Tanh Activation -ARMNN_AUTO_TEST_CASE(Tanh, TanhTest) -ARMNN_AUTO_TEST_CASE(TanhUint8, TanhUint8Test) -ARMNN_AUTO_TEST_CASE(TanhInt16, TanhInt16Test) - - -// Fully Connected -ARMNN_AUTO_TEST_CASE(SimpleFullyConnected, FullyConnectedFloat32Test, false, false) -ARMNN_AUTO_TEST_CASE(FullyConnectedUint8, FullyConnectedTest<DataType::QAsymmU8>, false) -ARMNN_AUTO_TEST_CASE(FullyConnectedQSymm16, FullyConnectedTest<DataType::QSymmS16>, false) -ARMNN_AUTO_TEST_CASE(SimpleFullyConnectedWithBias, FullyConnectedFloat32Test, true, false) -ARMNN_AUTO_TEST_CASE(FullyConnectedBiasedUint8, FullyConnectedTest<DataType::QAsymmU8>, true) -ARMNN_AUTO_TEST_CASE(FullyConnectedBiasedQSymm16, FullyConnectedTest<DataType::QSymmS16>, true) -ARMNN_AUTO_TEST_CASE(SimpleFullyConnectedWithTranspose, FullyConnectedFloat32Test, false, true) - -ARMNN_AUTO_TEST_CASE(FullyConnectedLarge, FullyConnectedLargeTest, false) -ARMNN_AUTO_TEST_CASE(FullyConnectedLargeTransposed, FullyConnectedLargeTest, true) - -// Splitter -ARMNN_AUTO_TEST_CASE(SimpleSplitterFloat32, SplitterFloat32Test) -ARMNN_AUTO_TEST_CASE(SimpleSplitterFloat16, SplitterFloat16Test) -ARMNN_AUTO_TEST_CASE(SimpleSplitterUint8, SplitterUint8Test) -ARMNN_AUTO_TEST_CASE(SimpleSplitterInt16, SplitterInt16Test) - -ARMNN_AUTO_TEST_CASE(CopyViaSplitterFloat32, CopyViaSplitterFloat32Test) -ARMNN_AUTO_TEST_CASE(CopyViaSplitterFloat16, CopyViaSplitterFloat16Test) -ARMNN_AUTO_TEST_CASE(CopyViaSplitterUint8, CopyViaSplitterUint8Test) -ARMNN_AUTO_TEST_CASE(CopyViaSplitterInt16, CopyViaSplitterInt16Test) - -// Concat -ARMNN_AUTO_TEST_CASE(SimpleConcat, ConcatTest) -ARMNN_AUTO_TEST_CASE(ConcatFloat16, ConcatFloat16Test) -ARMNN_AUTO_TEST_CASE(ConcatUint8, ConcatUint8Test) -ARMNN_AUTO_TEST_CASE(ConcatUint8DifferentQParams, ConcatUint8DifferentQParamsTest) -ARMNN_AUTO_TEST_CASE(ConcatUint16, ConcatUint16Test) -ARMNN_AUTO_TEST_CASE(ConcatUint8DifferentInputOutputQParam, - ConcatDifferentInputOutputQParamTest<DataType::QAsymmU8>, true) -ARMNN_AUTO_TEST_CASE(ConcatInt16DifferentInputOutputQParam, - ConcatDifferentInputOutputQParamTest<DataType::QSymmS16>, true) - -// Add -ARMNN_AUTO_TEST_CASE(SimpleAdd, AdditionTest) -ARMNN_AUTO_TEST_CASE(Add5d, Addition5dTest) -ARMNN_AUTO_TEST_CASE(AddBroadcast1Element, AdditionBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(AddBroadcast, AdditionBroadcastTest) - -ARMNN_AUTO_TEST_CASE(AdditionUint8, AdditionUint8Test) -ARMNN_AUTO_TEST_CASE(AddBroadcastUint8, AdditionBroadcastUint8Test) -ARMNN_AUTO_TEST_CASE(AddBroadcast1ElementUint8, AdditionBroadcast1ElementUint8Test) - -ARMNN_AUTO_TEST_CASE(AdditionInt16, AdditionInt16Test) -ARMNN_AUTO_TEST_CASE(AddBroadcastInt16, AdditionBroadcastInt16Test) -ARMNN_AUTO_TEST_CASE(AddBroadcast1ElementInt16, AdditionBroadcast1ElementInt16Test) - -// Sub -ARMNN_AUTO_TEST_CASE(SimpleSub, SubtractionTest) -ARMNN_AUTO_TEST_CASE(SubBroadcast1Element, SubtractionBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(SubBroadcast, SubtractionBroadcastTest) - -ARMNN_AUTO_TEST_CASE(SimpleSubFloat16, SubtractionTest) -ARMNN_AUTO_TEST_CASE(SubBroadcast1ElementFloat16, SubtractionBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(SubBroadcastFloat16, SubtractionBroadcastTest) - -ARMNN_AUTO_TEST_CASE(SubtractionUint8, SubtractionUint8Test) -ARMNN_AUTO_TEST_CASE(SubBroadcastUint8, SubtractionBroadcastUint8Test) -ARMNN_AUTO_TEST_CASE(SubBroadcast1ElementUint8, SubtractionBroadcast1ElementUint8Test) - -ARMNN_AUTO_TEST_CASE(SubtractionInt16, SubtractionInt16Test) -ARMNN_AUTO_TEST_CASE(SubBroadcastInt16, SubtractionBroadcastInt16Test) -ARMNN_AUTO_TEST_CASE(SubBroadcast1ElementInt16, SubtractionBroadcast1ElementInt16Test) - -// Div -ARMNN_AUTO_TEST_CASE(SimpleDivision, DivisionTest) -ARMNN_AUTO_TEST_CASE(DivisionByZero, DivisionByZeroTest) -ARMNN_AUTO_TEST_CASE(DivisionBroadcast1Element, DivisionBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(DivisionBroadcast1DVector, DivisionBroadcast1DVectorTest) - -ARMNN_AUTO_TEST_CASE(DivisionFloat16, DivisionFloat16Test) -ARMNN_AUTO_TEST_CASE(DivisionFloat16Broadcast1Element, DivisionBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(DivisionFloat16Broadcast1DVector, DivisionBroadcast1DVectorFloat16Test) - -// NOTE: division by zero for quantized div needs more attention -// see IVGCVSW-1849 -ARMNN_AUTO_TEST_CASE(DivisionUint8, DivisionUint8Test) -ARMNN_AUTO_TEST_CASE(DivisionUint8Broadcast1Element, DivisionBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(DivisionUint8Broadcast1DVector, DivisionBroadcast1DVectorUint8Test) - -ARMNN_AUTO_TEST_CASE(DivisionInt16, DivisionInt16Test) -ARMNN_AUTO_TEST_CASE(DivisionInt16Broadcast1Element, DivisionBroadcast1ElementInt16Test) -ARMNN_AUTO_TEST_CASE(DivisionInt16Broadcast1DVector, DivisionBroadcast1DVectorInt16Test) - -// Equal -ARMNN_AUTO_TEST_CASE(EqualSimple, EqualSimpleTest) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1Element, EqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVector, EqualBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE(EqualSimpleFloat16, EqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1ElementFloat16, EqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVectorFloat16, EqualBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE(EqualSimpleUint8, EqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1ElementUint8, EqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVectorUint8, EqualBroadcast1dVectorUint8Test) - -// Greater -ARMNN_AUTO_TEST_CASE(GreaterSimple, GreaterSimpleTest) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1Element, GreaterBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVector, GreaterBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE(GreaterSimpleFloat16, GreaterSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementFloat16, GreaterBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorFloat16, GreaterBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE(GreaterSimpleUint8, GreaterSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorUint8, GreaterBroadcast1dVectorUint8Test) - -// GreaterOrEqual -ARMNN_AUTO_TEST_CASE(GreaterOrEqualSimple, GreaterOrEqualSimpleTest) -ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1Element, GreaterOrEqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1dVector, GreaterOrEqualBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE(GreaterOrEqualSimpleFloat16, GreaterOrEqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1ElementFloat16, GreaterOrEqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1dVectorFloat16, GreaterOrEqualBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE(GreaterOrEqualSimpleUint8, GreaterOrEqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1ElementUint8, GreaterOrEqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1dVectorUint8, GreaterOrEqualBroadcast1dVectorUint8Test) - -// Less -ARMNN_AUTO_TEST_CASE(LessSimple, LessSimpleTest) -ARMNN_AUTO_TEST_CASE(LessBroadcast1Element, LessBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(LessBroadcast1dVector, LessBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE(LessSimpleFloat16, LessSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE(LessBroadcast1ElementFloat16, LessBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(LessBroadcast1dVectorFloat16, LessBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE(LessSimpleUint8, LessSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(LessBroadcast1ElementUint8, LessBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(LessBroadcast1dVectorUint8, LessBroadcast1dVectorUint8Test) - -// GreaterOrEqual -ARMNN_AUTO_TEST_CASE(LessOrEqualSimple, LessOrEqualSimpleTest) -ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1Element, LessOrEqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1dVector, LessOrEqualBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE(LessOrEqualSimpleFloat16, LessOrEqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1ElementFloat16, LessOrEqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1dVectorFloat16, LessOrEqualBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE(LessOrEqualSimpleUint8, LessOrEqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1ElementUint8, LessOrEqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1dVectorUint8, LessOrEqualBroadcast1dVectorUint8Test) - -// NotEqual -ARMNN_AUTO_TEST_CASE(NotEqualSimple, NotEqualSimpleTest) -ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1Element, NotEqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1dVector, NotEqualBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE(NotEqualSimpleFloat16, NotEqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1ElementFloat16, NotEqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1dVectorFloat16, NotEqualBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE(NotEqualSimpleUint8, NotEqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1ElementUint8, NotEqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1dVectorUint8, NotEqualBroadcast1dVectorUint8Test) - -// Max -ARMNN_AUTO_TEST_CASE(SimpleMaximum, MaximumSimpleTest) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1Element, MaximumBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1DVector, MaximumBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE(MaximumFloat16, MaximumFloat16Test) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1ElementFloat16, MaximumBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1DVectorFloat16, MaximumBroadcast1DVectorFloat16Test) -ARMNN_AUTO_TEST_CASE(MaximumUint8, MaximumUint8Test) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1ElementUint8, MaximumBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1DVectorUint8, MaximumBroadcast1DVectorUint8Test) -ARMNN_AUTO_TEST_CASE(MaximumInt16, MaximumInt16Test) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1ElementInt16, MaximumBroadcast1ElementInt16Test) -ARMNN_AUTO_TEST_CASE(MaximumBroadcast1DVectorInt16, MaximumBroadcast1DVectorInt16Test) - -// Min -ARMNN_AUTO_TEST_CASE(SimpleMinimum1, MinimumBroadcast1ElementTest1) -ARMNN_AUTO_TEST_CASE(SimpleMinimum2, MinimumBroadcast1ElementTest2) -ARMNN_AUTO_TEST_CASE(Minimum1DVectorUint8, MinimumBroadcast1DVectorUint8Test) -ARMNN_AUTO_TEST_CASE(MinimumFloat16, MinimumFloat16Test) -ARMNN_AUTO_TEST_CASE(MinimumBroadcast1ElementFloat16, MinimumBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE(MinimumBroadcast1DVectorFloat16, MinimumBroadcast1DVectorFloat16Test) -ARMNN_AUTO_TEST_CASE(MinimumInt16, MinimumInt16Test) -ARMNN_AUTO_TEST_CASE(MinimumBroadcast1ElementInt16, MinimumBroadcast1ElementInt16Test) -ARMNN_AUTO_TEST_CASE(MinimumBroadcast1DVectorInt16, MinimumBroadcast1DVectorInt16Test) - -// Mul -ARMNN_AUTO_TEST_CASE(SimpleMultiplication, MultiplicationTest) -ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1Element, MultiplicationBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1DVector, MultiplicationBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE(MultiplicationUint8, MultiplicationUint8Test) -ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1ElementUint8, MultiplicationBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1DVectorUint8, MultiplicationBroadcast1DVectorUint8Test) -ARMNN_AUTO_TEST_CASE(MultiplicationInt16, MultiplicationInt16Test) -ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1ElementInt16, MultiplicationBroadcast1ElementInt16Test) -ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1DVectorInt16, MultiplicationBroadcast1DVectorInt16Test) -ARMNN_AUTO_TEST_CASE(Multiplication5d, Multiplication5dTest) - -// Batch Norm -ARMNN_AUTO_TEST_CASE(BatchNormFloat32, BatchNormFloat32Test) -ARMNN_AUTO_TEST_CASE(BatchNormFloat32Nhwc, BatchNormFloat32NhwcTest) -ARMNN_AUTO_TEST_CASE(BatchNormFloat16, BatchNormFloat16Test) -ARMNN_AUTO_TEST_CASE(BatchNormFloat16Nhwc, BatchNormFloat16NhwcTest) -ARMNN_AUTO_TEST_CASE(BatchNormUint8, BatchNormUint8Test) -ARMNN_AUTO_TEST_CASE(BatchNormUint8Nhwc, BatchNormUint8NhwcTest) -ARMNN_AUTO_TEST_CASE(BatchNormInt16, BatchNormInt16Test) -ARMNN_AUTO_TEST_CASE(BatchNormInt16Nhwc, BatchNormInt16NhwcTest) - -// Resize Bilinear - NCHW -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinear, - SimpleResizeBilinearTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearFloat16, - SimpleResizeBilinearTest<DataType::Float16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8, - SimpleResizeBilinearTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint16, - SimpleResizeBilinearTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearNop, - ResizeBilinearNopTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearNopFloat16, - ResizeBilinearNopTest<DataType::Float16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8, - ResizeBilinearNopTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(esizeBilinearNopUint16, - SimpleResizeBilinearTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMin, - ResizeBilinearSqMinTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinFloat16, - ResizeBilinearSqMinTest<DataType::Float16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8, - ResizeBilinearSqMinTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint16, - SimpleResizeBilinearTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMin, - ResizeBilinearMinTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMinFloat16, - ResizeBilinearMinTest<DataType::Float16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8, - ResizeBilinearMinTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint16, - SimpleResizeBilinearTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMag, - ResizeBilinearMagTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMagFloat16, - ResizeBilinearMagTest<DataType::Float16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8, - ResizeBilinearMagTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint16, - SimpleResizeBilinearTest<DataType::QSymmS16>, - DataLayout::NCHW) - -// Resize Bilinear - NHWC -ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwc, - ResizeBilinearNopTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwcFloat16, - ResizeBilinearNopTest<DataType::Float16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8Nhwc, - ResizeBilinearNopTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint16Nhwc, - ResizeBilinearNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwc, - SimpleResizeBilinearTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwcFloat16, - SimpleResizeBilinearTest<DataType::Float16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8Nhwc, - SimpleResizeBilinearTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint16Nhwc, - ResizeBilinearNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwc, - ResizeBilinearSqMinTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwcFloat16, - ResizeBilinearSqMinTest<DataType::Float16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8Nhwc, - ResizeBilinearSqMinTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint16Nhwc, - ResizeBilinearNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwc, - ResizeBilinearMinTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwcFloat16, - ResizeBilinearMinTest<DataType::Float16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8Nhwc, - ResizeBilinearMinTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint16Nhwc, - ResizeBilinearNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMagNhwc, - ResizeBilinearMagTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMagNhwcFloat16, - ResizeBilinearMagTest<DataType::Float16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8Nhwc, - ResizeBilinearMagTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint16Nhwc, - ResizeBilinearNopTest<DataType::QSymmS16>, - DataLayout::NHWC) - -// Resize NearestNeighbor - NCHW -ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighbor, - SimpleResizeNearestNeighborTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8, - SimpleResizeNearestNeighborTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint16, - SimpleResizeNearestNeighborTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNop, - ResizeNearestNeighborNopTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8, - ResizeNearestNeighborNopTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(esizeNearestNeighborNopUint16, - SimpleResizeNearestNeighborTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMin, - ResizeNearestNeighborSqMinTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8, - ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint16, - SimpleResizeNearestNeighborTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMin, - ResizeNearestNeighborMinTest<DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8, - ResizeNearestNeighborMinTest<DataType::QAsymmU8>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint16, - SimpleResizeNearestNeighborTest<DataType::QSymmS16>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMag, - ResizeNearestNeighborMagTest<DataType::Float32>, - DataLayout::NCHW, 0.10f, 50, 0.11f, 20) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8, - ResizeNearestNeighborMagTest<DataType::QAsymmU8>, - DataLayout::NCHW, 0.10f, 50, 0.11f, 20) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint16, - SimpleResizeNearestNeighborTest<DataType::QSymmS16>, - DataLayout::NCHW) - -// Resize NearestNeighbor - NHWC -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopNhwc, - ResizeNearestNeighborNopTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8Nhwc, - ResizeNearestNeighborNopTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint16Nhwc, - ResizeNearestNeighborNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborNhwc, - SimpleResizeNearestNeighborTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8Nhwc, - SimpleResizeNearestNeighborTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint16Nhwc, - ResizeNearestNeighborNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinNhwc, - ResizeNearestNeighborSqMinTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8Nhwc, - ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint16Nhwc, - ResizeNearestNeighborNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinNhwc, - ResizeNearestNeighborMinTest<DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8Nhwc, - ResizeNearestNeighborMinTest<DataType::QAsymmU8>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint16Nhwc, - ResizeNearestNeighborNopTest<DataType::QSymmS16>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagNhwc, - ResizeNearestNeighborMagTest<DataType::Float32>, - DataLayout::NHWC, 0.10f, 50, 0.11f, 20) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8Nhwc, - ResizeNearestNeighborMagTest<DataType::QAsymmU8>, - DataLayout::NHWC, 0.10f, 50, 0.11f, 20) -ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint16Nhwc, - ResizeNearestNeighborNopTest<DataType::QSymmS16>, - DataLayout::NHWC) - -// Fake Quantization -ARMNN_AUTO_TEST_CASE(FakeQuantization, FakeQuantizationTest) - -// L2 Normalization -ARMNN_AUTO_TEST_CASE(L2Normalization1d, L2Normalization1dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization2d, L2Normalization2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization3d, L2Normalization3dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization4d, L2Normalization4dTest, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(L2Normalization1dInt16, L2Normalization1dInt16Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization2dInt16, L2Normalization2dInt16Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization3dInt16, L2Normalization3dInt16Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization4dInt16, L2Normalization4dInt16Test, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(L2Normalization1dUint8, L2Normalization1dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization2dUint8, L2Normalization2dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization3dUint8, L2Normalization3dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization4dUint8, L2Normalization4dUint8Test, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(L2Normalization1dNhwc, L2Normalization1dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization2dNhwc, L2Normalization2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization3dNhwc, L2Normalization3dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization4dNhwc, L2Normalization4dTest, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(L2Normalization1dInt16Nhwc, L2Normalization1dInt16Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization2dInt16Nhwc, L2Normalization2dInt16Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization3dInt16Nhwc, L2Normalization3dInt16Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization4dInt16Nhwc, L2Normalization4dInt16Test, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(L2Normalization1dUint8Nhwc, L2Normalization1dUint8Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization2dUint8Nhwc, L2Normalization2dUint8Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization3dUint8Nhwc, L2Normalization3dUint8Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization4dUint8Nhwc, L2Normalization4dUint8Test, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE(L2Normalization2dShape, L2Normalization2dShapeTest); - -ARMNN_AUTO_TEST_CASE(L2NormalizationDefaultEpsilon, L2NormalizationDefaultEpsilonTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2NormalizationNonDefaultEpsilon, L2NormalizationNonDefaultEpsilonTest, DataLayout::NCHW) - -// LogSoftmax -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat32_1, LogSoftmaxTest1<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat32_2, LogSoftmaxTest2<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat32_3, LogSoftmaxTest3<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat32_4, LogSoftmaxTest4<DataType::Float32>) - -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat16_1, LogSoftmaxTest1<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat16_2, LogSoftmaxTest2<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat16_3, LogSoftmaxTest3<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(LogSoftmaxFloat16_4, LogSoftmaxTest4<DataType::Float16>) - -// Pad -ARMNN_AUTO_TEST_CASE(PadFloat322d, PadFloat322dTest) -ARMNN_AUTO_TEST_CASE(PadFloat322dCustomPadding, PadFloat322dCustomPaddingTest) -ARMNN_AUTO_TEST_CASE(PadFloat323d, PadFloat323dTest) -ARMNN_AUTO_TEST_CASE(PadFloat324d, PadFloat324dTest) - -ARMNN_AUTO_TEST_CASE(PadUint82d, PadUint82dTest) -ARMNN_AUTO_TEST_CASE(PadUint82dCustomPadding, PadUint82dCustomPaddingTest) -ARMNN_AUTO_TEST_CASE(PadUint83d, PadUint83dTest) -ARMNN_AUTO_TEST_CASE(PadUint84d, PadUint84dTest) - -ARMNN_AUTO_TEST_CASE(Pad2dQSymm16, Pad2dTestCommon<DataType::QSymmS16>, 2.0f, 0, 0.0f) -ARMNN_AUTO_TEST_CASE(Pad2dQSymm16CustomPadding, Pad2dTestCommon<DataType::QSymmS16>, 2.0f, 0, 1.0f) -ARMNN_AUTO_TEST_CASE(Pad3dQSymm16, Pad3dTestCommon<DataType::QSymmS16>, 2.0f, 0) -ARMNN_AUTO_TEST_CASE(Pad4dQSymm16, Pad4dTestCommon<DataType::QSymmS16>, 2.0f, 0) - -// Constant -ARMNN_AUTO_TEST_CASE(Constant, ConstantTest) -ARMNN_AUTO_TEST_CASE(ConstantUint8, ConstantUint8CustomQuantizationScaleAndOffsetTest) -ARMNN_AUTO_TEST_CASE(ConstantInt16, ConstantInt16CustomQuantizationScaleAndOffsetTest) - -// Concat -ARMNN_AUTO_TEST_CASE(Concat1d, Concat1dTest) -ARMNN_AUTO_TEST_CASE(Concat1dUint8, Concat1dUint8Test) - -ARMNN_AUTO_TEST_CASE(Concat2dDim0, Concat2dDim0Test) -ARMNN_AUTO_TEST_CASE(Concat2dDim0Uint8, Concat2dDim0Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat2dDim1, Concat2dDim1Test) -ARMNN_AUTO_TEST_CASE(Concat2dDim1Uint8, Concat2dDim1Uint8Test) - -ARMNN_AUTO_TEST_CASE(Concat2dDim0DiffInputDims, Concat2dDim0DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE(Concat2dDim0DiffInputDimsUint8, Concat2dDim0DiffInputDimsUint8Test) -ARMNN_AUTO_TEST_CASE(Concat2dDim1DiffInputDims, Concat2dDim1DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE(Concat2dDim1DiffInputDimsUint8, Concat2dDim1DiffInputDimsUint8Test) - -ARMNN_AUTO_TEST_CASE(Concat3dDim0, Concat3dDim0Test) -ARMNN_AUTO_TEST_CASE(Concat3dDim0Uint8, Concat3dDim0Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat3dDim1, Concat3dDim1Test) -ARMNN_AUTO_TEST_CASE(Concat3dDim1Uint8, Concat3dDim1Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat3dDim2, Concat3dDim2Test, true) -ARMNN_AUTO_TEST_CASE(Concat3dDim2Uint8, Concat3dDim2Uint8Test, true) - -ARMNN_AUTO_TEST_CASE(Concat3dDim0DiffInputDims, Concat3dDim0DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE(Concat3dDim0DiffInputDimsUint8, Concat3dDim0DiffInputDimsUint8Test) -ARMNN_AUTO_TEST_CASE(Concat3dDim1DiffInputDims, Concat3dDim1DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE(Concat3dDim1DiffInputDimsUint8, Concat3dDim1DiffInputDimsUint8Test) -ARMNN_AUTO_TEST_CASE(Concat3dDim2DiffInputDims, Concat3dDim2DiffInputDimsTest, true) -ARMNN_AUTO_TEST_CASE(Concat3dDim2DiffInputDimsUint8, Concat3dDim2DiffInputDimsUint8Test, true) - -ARMNN_AUTO_TEST_CASE(Concat4dDim0, Concat4dDim0Test) -ARMNN_AUTO_TEST_CASE(Concat4dDim1, Concat4dDim1Test) -ARMNN_AUTO_TEST_CASE(Concat4dDim2, Concat4dDim2Test) -ARMNN_AUTO_TEST_CASE(Concat4dDim3, Concat4dDim3Test, true) -ARMNN_AUTO_TEST_CASE(Concat4dDim0Uint8, Concat4dDim0Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat4dDim1Uint8, Concat4dDim1Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat4dDim2Uint8, Concat4dDim2Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat4dDim3Uint8, Concat4dDim3Uint8Test, true) - -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim0, Concat4dDiffShapeDim0Test) -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim1, Concat4dDiffShapeDim1Test) -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim2, Concat4dDiffShapeDim2Test) -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim3, Concat4dDiffShapeDim3Test, true) -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim0Uint8, Concat4dDiffShapeDim0Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim1Uint8, Concat4dDiffShapeDim1Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim2Uint8, Concat4dDiffShapeDim2Uint8Test) -ARMNN_AUTO_TEST_CASE(Concat4dDiffShapeDim3Uint8, Concat4dDiffShapeDim3Uint8Test, true) - -// Floor -ARMNN_AUTO_TEST_CASE(SimpleFloor, SimpleFloorTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(SimpleFloorFloat16, SimpleFloorTest<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(SimpleFloorQuantisedSymm16, SimpleFloorTest<DataType::QSymmS16>) - -// Reshape -ARMNN_AUTO_TEST_CASE(SimpleReshapeFloat32, SimpleReshapeTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(SimpleReshapeQuantisedAsymm8, SimpleReshapeTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(SimpleReshapeQuantisedSymm16, SimpleReshapeTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(Reshape5d, Reshape5dTest<DataType::Float32>) - -// Rsqrt -ARMNN_AUTO_TEST_CASE(Rsqrt2d, Rsqrt2dTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(Rsqrt3d, Rsqrt3dTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(RsqrtZero, RsqrtZeroTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(RsqrtNegative, RsqrtNegativeTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(Rsqrt2dFloat16, Rsqrt2dTest<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(Rsqrt3dFloat16, Rsqrt3dTest<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(Rsqrt2dQuantisedAsymm8, Rsqrt2dTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(Rsqrt3dQuantisedAsymm8, Rsqrt3dTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(Rsqrt2dQuantisedSymm16, Rsqrt2dTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(Rsqrt3dQuantisedSymm16, Rsqrt3dTest<DataType::QSymmS16>) - -// Permute -ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1Test, PermuteValueSet1Test<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2Test, PermuteValueSet2Test<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3Test, PermuteValueSet3Test<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(SimplePermuteQASymm8, SimplePermuteTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(SimplePermuteQSymm16, SimplePermuteTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(PermuteQSymm16ValueSet1Test, PermuteValueSet1Test<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(PermuteQSymm16ValueSet2Test, PermuteValueSet2Test<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(PermuteQSymm16ValueSet3Test, PermuteValueSet3Test<DataType::QSymmS16>) - -// Lstm -BOOST_AUTO_TEST_CASE(LstmUtilsZeroVector) { - LstmUtilsZeroVectorTest(); } -BOOST_AUTO_TEST_CASE(LstmUtilsMeanStddevNormalization) { - LstmUtilsMeanStddevNormalizationNoneZeroInputTest(); - LstmUtilsMeanStddevNormalizationAllZeroInputTest(); - LstmUtilsMeanStddevNormalizationMixedZeroInputTest(); } -BOOST_AUTO_TEST_CASE(LstmUtilsVectorBatchVectorCwiseProduct) { - LstmUtilsVectorBatchVectorCwiseProductTest(); } -BOOST_AUTO_TEST_CASE(LstmUtilsVectorBatchVectorAdd) { - LstmUtilsVectorBatchVectorAddTest(); } - -ARMNN_AUTO_TEST_CASE(LstmLayerFloat32WithCifgWithPeepholeNoProjection, - LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest) -ARMNN_AUTO_TEST_CASE(LstmLayerFloat32NoCifgNoPeepholeNoProjection, - LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest) -ARMNN_AUTO_TEST_CASE(LstmLayerFloat32NoCifgWithPeepholeWithProjection, - LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest) - -ARMNN_AUTO_TEST_CASE(LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNorm, - LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNormTest) - -ARMNN_AUTO_TEST_CASE(LstmLayerInt16NoCifgNoPeepholeNoProjection, - LstmLayerInt16NoCifgNoPeepholeNoProjectionTest) -ARMNN_AUTO_TEST_CASE(LstmLayerInt16WithCifgWithPeepholeNoProjection, - LstmLayerInt16WithCifgWithPeepholeNoProjectionTest) -ARMNN_AUTO_TEST_CASE(LstmLayerInt16NoCifgWithPeepholeWithProjection, - LstmLayerInt16NoCifgWithPeepholeWithProjectionTest) -ARMNN_AUTO_TEST_CASE(LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16Constant, - LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16ConstantTest) - -// Convert from Float16 to Float32 -ARMNN_AUTO_TEST_CASE(SimpleConvertFp16ToFp32, SimpleConvertFp16ToFp32Test) -// Convert from Float32 to Float16 -ARMNN_AUTO_TEST_CASE(SimpleConvertFp32ToFp16, SimpleConvertFp32ToFp16Test) - -// Mean -ARMNN_AUTO_TEST_CASE(MeanSimpleFloat32, MeanSimpleTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(MeanSimpleAxisFloat32, MeanSimpleAxisTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(MeanKeepDimsFloat32, MeanKeepDimsTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(MeanMultipleDimsFloat32, MeanMultipleDimsTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(MeanVts1Float32, MeanVts1Test<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(MeanVts2Float32, MeanVts2Test<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(MeanVts3Float32, MeanVts3Test<DataType::Float32>) - -ARMNN_AUTO_TEST_CASE(MeanSimpleQuantisedAsymm8, MeanSimpleTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(MeanSimpleAxisQuantisedAsymm8, MeanSimpleAxisTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(MeanKeepDimsQuantisedAsymm8, MeanKeepDimsTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(MeanMultipleDimsQuantisedAsymm8, MeanMultipleDimsTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(MeanVts1QuantisedAsymm8, MeanVts1Test<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(MeanVts2QuantisedAsymm8, MeanVts2Test<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(MeanVts3QuantisedAsymm8, MeanVts3Test<DataType::QAsymmU8>) - -ARMNN_AUTO_TEST_CASE(MeanSimpleQuantisedSymm16, MeanSimpleTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(MeanSimpleAxisQuantisedSymm16, MeanSimpleAxisTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(MeanKeepDimsQuantisedSymm16, MeanKeepDimsTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(MeanMultipleDimsQuantisedSymm16, MeanMultipleDimsTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(MeanVts1QuantisedSymm16, MeanVts1Test<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(MeanVts2QuantisedSymm16, MeanVts2Test<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(MeanVts3QuantisedSymm16, MeanVts3Test<DataType::QSymmS16>) - -ARMNN_AUTO_TEST_CASE(AdditionAfterMaxPool, AdditionAfterMaxPoolTest) - -// ArgMinMax -ARMNN_AUTO_TEST_CASE(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(ArgMinChannelFloat32, ArgMinChannelTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(ArgMaxChannelFloat32, ArgMaxChannelTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(ArgMaxHeightFloat32, ArgMaxHeightTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(ArgMinWidthFloat32, ArgMinWidthTest<DataType::Float32>) - -ARMNN_AUTO_TEST_CASE(ArgMaxSigned32, ArgMaxSimpleTest<DataType::Signed32>) -ARMNN_AUTO_TEST_CASE(ArgMinSigned32, ArgMinSimpleTest<DataType::Signed32>) -ARMNN_AUTO_TEST_CASE(ArgMinChannelSigned32, ArgMinChannelTest<DataType::Signed32>) -ARMNN_AUTO_TEST_CASE(ArgMaxChannelSigned32, ArgMaxChannelTest<DataType::Signed32>) -ARMNN_AUTO_TEST_CASE(ArgMaxHeightSigned32, ArgMaxHeightTest<DataType::Signed32>) -ARMNN_AUTO_TEST_CASE(ArgMinWidthSigned32, ArgMinWidthTest<DataType::Signed32>) - -ARMNN_AUTO_TEST_CASE(ArgMaxSimpleQuantisedAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(ArgMinSimpleQuantisedAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(ArgMinChannelQuantisedAsymm8, ArgMinChannelTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(ArgMaxChannelQuantisedAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>) - -ARMNN_AUTO_TEST_CASE(ArgMaxSimpleQuantisedSymm16, ArgMaxSimpleTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(ArgMinSimpleQuantisedSymm16, ArgMinSimpleTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(ArgMinChannelQuantisedSymm16, ArgMinChannelTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(ArgMaxChannelQuantisedSymm16, ArgMaxChannelTest<DataType::QSymmS16>) - -// Space To Batch Nd -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleFloat32, SpaceToBatchNdSimpleFloat32Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsFloat32, SpaceToBatchNdMultiChannelsFloat32Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockFloat32, SpaceToBatchNdMultiBlockFloat32Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingFloat32, SpaceToBatchNdPaddingFloat32Test) - -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleFloat16, SpaceToBatchNdSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsFloat16, SpaceToBatchNdMultiChannelsFloat16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockFloat16, SpaceToBatchNdMultiBlockFloat16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingFloat16, SpaceToBatchNdPaddingFloat16Test) - -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleUint8, SpaceToBatchNdSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsUint8, SpaceToBatchNdMultiChannelsUint8Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockUint8, SpaceToBatchNdMultiBlockUint8Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingUint8, SpaceToBatchNdPaddingUint8Test) - -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleNhwcFloat32, SpaceToBatchNdSimpleNhwcFloat32Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsNhwcFloat32, SpaceToBatchNdMultiChannelsNhwcFloat32Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockNhwcFloat32, SpaceToBatchNdMultiBlockNhwcFloat32Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingNhwcFloat32, SpaceToBatchNdPaddingNhwcFloat32Test) - -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleNhwcFloat16, SpaceToBatchNdSimpleNhwcFloat16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsNhwcFloat16, SpaceToBatchNdMultiChannelsNhwcFloat16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockNhwcFloat16, SpaceToBatchNdMultiBlockNhwcFloat16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingNhwcFloat16, SpaceToBatchNdPaddingNhwcFloat16Test) - -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleNhwcUint8, SpaceToBatchNdSimpleNhwcUint8Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsNhwcUint8, SpaceToBatchNdMultiChannelsNhwcUint8Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockNhwcUint8, SpaceToBatchNdMultiBlockNhwcUint8Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingNhwcUint8, SpaceToBatchNdPaddingNhwcUint8Test) - -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleUint16, SpaceToBatchNdSimpleUint16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsUint16, SpaceToBatchNdMultiChannelsUint16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockUint16, SpaceToBatchNdMultiBlockUint16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingUint16, SpaceToBatchNdPaddingUint16Test) - -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleNhwcUint16, SpaceToBatchNdSimpleNhwcUint16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiChannelsNhwcUint16, SpaceToBatchNdMultiChannelsNhwcUint16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdMultiBlockNhwcUint16, SpaceToBatchNdMultiBlockNhwcUint16Test) -ARMNN_AUTO_TEST_CASE(SpaceToBatchNdPaddingNhwcUint16, SpaceToBatchNdPaddingNhwcUint16Test) - -// BatchToSpace -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat32_1, BatchToSpaceNdNhwcTest1<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat32_2, BatchToSpaceNdNhwcTest2<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat32_3, BatchToSpaceNdNhwcTest3<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat32_4, BatchToSpaceNdNhwcTest4<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat32_5, BatchToSpaceNdNhwcTest5<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat32_6, BatchToSpaceNdNhwcTest6<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat32_7, BatchToSpaceNdNhwcTest7<DataType::Float32>) - -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat16_1, BatchToSpaceNdNhwcTest1<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat16_2, BatchToSpaceNdNhwcTest2<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat16_3, BatchToSpaceNdNhwcTest3<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat16_4, BatchToSpaceNdNhwcTest4<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat16_5, BatchToSpaceNdNhwcTest5<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat16_6, BatchToSpaceNdNhwcTest6<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcFloat16_7, BatchToSpaceNdNhwcTest7<DataType::Float16>) - -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcUint1, BatchToSpaceNdNhwcTest1<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcUint2, BatchToSpaceNdNhwcTest2<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcUint3, BatchToSpaceNdNhwcTest3<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcUint4, BatchToSpaceNdNhwcTest4<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcUint5, BatchToSpaceNdNhwcTest5<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcUint6, BatchToSpaceNdNhwcTest6<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcUint7, BatchToSpaceNdNhwcTest7<DataType::QAsymmU8>) - -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcQsymm16_1, BatchToSpaceNdNhwcTest1<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcQsymm16_2, BatchToSpaceNdNhwcTest2<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcQsymm16_3, BatchToSpaceNdNhwcTest3<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcQsymm16_4, BatchToSpaceNdNhwcTest4<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcQsymm16_5, BatchToSpaceNdNhwcTest5<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcQsymm16_6, BatchToSpaceNdNhwcTest6<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNhwcQsymm16_7, BatchToSpaceNdNhwcTest7<DataType::QSymmS16>) - -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwFloat16_1, BatchToSpaceNdNchwTest1<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwFloat16_2, BatchToSpaceNdNchwTest2<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwFloat16_3, BatchToSpaceNdNchwTest3<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwFloat16_4, BatchToSpaceNdNchwTest4<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwFloat16_5, BatchToSpaceNdNchwTest5<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwFloat16_6, BatchToSpaceNdNchwTest6<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwFloat16_7, BatchToSpaceNdNchwTest7<DataType::Float16>) - -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwUint1, BatchToSpaceNdNchwTest1<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwUint2, BatchToSpaceNdNchwTest2<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwUint3, BatchToSpaceNdNchwTest3<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwUint4, BatchToSpaceNdNchwTest4<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwUint5, BatchToSpaceNdNchwTest5<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwUint6, BatchToSpaceNdNchwTest6<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwUint7, BatchToSpaceNdNchwTest7<DataType::QAsymmU8>) - -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwQsymm16_1, BatchToSpaceNdNchwTest1<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwQsymm16_2, BatchToSpaceNdNchwTest2<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwQsymm16_3, BatchToSpaceNdNchwTest3<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwQsymm16_4, BatchToSpaceNdNchwTest4<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwQsymm16_5, BatchToSpaceNdNchwTest5<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwQsymm16_6, BatchToSpaceNdNchwTest6<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(BatchToSpaceNdNchwQsymm16_7, BatchToSpaceNdNchwTest7<DataType::QSymmS16>) - -// DepthToSpace -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_1, DepthToSpaceTest1<DataType::Float32>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_2, DepthToSpaceTest2<DataType::Float32>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_3, DepthToSpaceTest3<DataType::Float32>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_4, DepthToSpaceTest4<DataType::Float32>, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_1, DepthToSpaceTest1<DataType::Float16>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_2, DepthToSpaceTest2<DataType::Float16>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_3, DepthToSpaceTest3<DataType::Float16>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_4, DepthToSpaceTest4<DataType::Float16>, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_1, DepthToSpaceTest1<DataType::QAsymmU8>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_2, DepthToSpaceTest2<DataType::QAsymmU8>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_3, DepthToSpaceTest3<DataType::QAsymmU8>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_4, DepthToSpaceTest4<DataType::QAsymmU8>, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_1, DepthToSpaceTest1<DataType::QSymmS16>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_2, DepthToSpaceTest2<DataType::QSymmS16>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_3, DepthToSpaceTest3<DataType::QSymmS16>, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_4, DepthToSpaceTest4<DataType::QSymmS16>, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_1, DepthToSpaceTest1<DataType::Float32>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_2, DepthToSpaceTest2<DataType::Float32>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_3, DepthToSpaceTest3<DataType::Float32>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_4, DepthToSpaceTest4<DataType::Float32>, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_1, DepthToSpaceTest1<DataType::Float16>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_2, DepthToSpaceTest2<DataType::Float16>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_3, DepthToSpaceTest3<DataType::Float16>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_4, DepthToSpaceTest4<DataType::Float16>, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_1, DepthToSpaceTest1<DataType::QAsymmU8>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_2, DepthToSpaceTest2<DataType::QAsymmU8>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_3, DepthToSpaceTest3<DataType::QAsymmU8>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_4, DepthToSpaceTest4<DataType::QAsymmU8>, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_1, DepthToSpaceTest1<DataType::QSymmS16>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_2, DepthToSpaceTest2<DataType::QSymmS16>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_3, DepthToSpaceTest3<DataType::QSymmS16>, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_4, DepthToSpaceTest4<DataType::QSymmS16>, DataLayout::NHWC); - -// SpaceToDepth -ARMNN_AUTO_TEST_CASE(SpaceToDepthNchwAsymmQ8, SpaceToDepthNchwAsymmQ8Test) -ARMNN_AUTO_TEST_CASE(SpaceToDepthNhwcAsymmQ8, SpaceToDepthNhwcAsymmQ8Test) - -ARMNN_AUTO_TEST_CASE(SpaceToDepthNhwc1Float32, SpaceToDepthNhwcFloat32Test1) -ARMNN_AUTO_TEST_CASE(SpaceToDepthNchw1Float32, SpaceToDepthNchwFloat32Test1) - -ARMNN_AUTO_TEST_CASE(SpaceToDepthNhwc2Float32, SpaceToDepthNhwcFloat32Test2) -ARMNN_AUTO_TEST_CASE(SpaceToDepthNchw2Float32, SpaceToDepthNchwFloat32Test2) - -ARMNN_AUTO_TEST_CASE(SpaceToDepthNhwcQSymm16, SpaceToDepthNhwcQSymm16Test) -ARMNN_AUTO_TEST_CASE(SpaceToDepthNchwQSymm16, SpaceToDepthNchwQSymm16Test) - -// Strided Slice -ARMNN_AUTO_TEST_CASE(StridedSlice4dFloat32, StridedSlice4dFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSlice4dReverseFloat32, StridedSlice4dReverseFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceSimpleStrideFloat32, StridedSliceSimpleStrideFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceSimpleRangeMaskFloat32, StridedSliceSimpleRangeMaskFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskFloat32, StridedSliceShrinkAxisMaskFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskCTSFloat32, StridedSliceShrinkAxisMaskCTSFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0Dim3Float32, - StridedSliceShrinkAxisMaskBitPosition0Dim3Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0Float32, StridedSliceShrinkAxisMaskBitPosition0Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition1Float32, StridedSliceShrinkAxisMaskBitPosition1Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition2Float32, StridedSliceShrinkAxisMaskBitPosition2Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition3Float32, StridedSliceShrinkAxisMaskBitPosition3Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And1Float32, - StridedSliceShrinkAxisMaskBitPosition0And1Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And2Float32, - StridedSliceShrinkAxisMaskBitPosition0And2Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And3Float32, - StridedSliceShrinkAxisMaskBitPosition0And3Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And1And3Float32, - StridedSliceShrinkAxisMaskBitPosition0And1And3Float32Test) -ARMNN_AUTO_TEST_CASE(StridedSlice3dFloat32, StridedSlice3dFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSlice3dReverseFloat32, StridedSlice3dReverseFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSlice2dFloat32, StridedSlice2dFloat32Test) -ARMNN_AUTO_TEST_CASE(StridedSlice2dReverseFloat32, StridedSlice2dReverseFloat32Test) - -ARMNN_AUTO_TEST_CASE(StridedSlice4dUint8, StridedSlice4dUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSlice4dReverseUint8, StridedSlice4dReverseUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceSimpleStrideUint8, StridedSliceSimpleStrideUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceSimpleRangeMaskUint8, StridedSliceSimpleRangeMaskUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskUint8, StridedSliceShrinkAxisMaskUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0Dim3Uint8, - StridedSliceShrinkAxisMaskBitPosition0Dim3Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0Uint8, StridedSliceShrinkAxisMaskBitPosition0Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition1Uint8, StridedSliceShrinkAxisMaskBitPosition1Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition2Uint8, StridedSliceShrinkAxisMaskBitPosition2Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition3Uint8, StridedSliceShrinkAxisMaskBitPosition3Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And1Uint8, - StridedSliceShrinkAxisMaskBitPosition0And1Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And2Uint8, - StridedSliceShrinkAxisMaskBitPosition0And2Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And3Uint8, - StridedSliceShrinkAxisMaskBitPosition0And3Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskBitPosition0And1And3Uint8, - StridedSliceShrinkAxisMaskBitPosition0And1And3Uint8Test) -ARMNN_AUTO_TEST_CASE(StridedSlice3dUint8, StridedSlice3dUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSlice3dReverseUint8, StridedSlice3dReverseUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSlice2dUint8, StridedSlice2dUint8Test) -ARMNN_AUTO_TEST_CASE(StridedSlice2dReverseUint8, StridedSlice2dReverseUint8Test) - -ARMNN_AUTO_TEST_CASE(StridedSlice4dInt16, StridedSlice4dInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSlice4dReverseInt16, StridedSlice4dReverseInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSliceSimpleStrideInt16, StridedSliceSimpleStrideInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSliceSimpleRangeMaskInt16, StridedSliceSimpleRangeMaskInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSliceShrinkAxisMaskInt16, StridedSliceShrinkAxisMaskInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSlice3dInt16, StridedSlice3dInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSlice3dReverseInt16, StridedSlice3dReverseInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSlice2dInt16, StridedSlice2dInt16Test) -ARMNN_AUTO_TEST_CASE(StridedSlice2dReverseInt16, StridedSlice2dReverseInt16Test) - -// Debug -ARMNN_AUTO_TEST_CASE(Debug4dFloat32, Debug4dFloat32Test) -ARMNN_AUTO_TEST_CASE(Debug3dFloat32, Debug3dFloat32Test) -ARMNN_AUTO_TEST_CASE(Debug2dFloat32, Debug2dFloat32Test) -ARMNN_AUTO_TEST_CASE(Debug1dFloat32, Debug1dFloat32Test) - -ARMNN_AUTO_TEST_CASE(Debug4dUint8, Debug4dUint8Test) -ARMNN_AUTO_TEST_CASE(Debug3dUint8, Debug3dUint8Test) -ARMNN_AUTO_TEST_CASE(Debug2dUint8, Debug2dUint8Test) -ARMNN_AUTO_TEST_CASE(Debug1dUint8, Debug1dUint8Test) - -ARMNN_AUTO_TEST_CASE(Debug4dQSymm16, Debug4dInt16Test) -ARMNN_AUTO_TEST_CASE(Debug3dQSymm16, Debug3dInt16Test) -ARMNN_AUTO_TEST_CASE(Debug2dQSymm16, Debug2dInt16Test) -ARMNN_AUTO_TEST_CASE(Debug1dQSymm16, Debug1dInt16Test) - -// Gather -ARMNN_AUTO_TEST_CASE(Gather1dParamsFloat32, Gather1dParamsFloat32Test) -ARMNN_AUTO_TEST_CASE(Gather1dParamsFloat16, Gather1dParamsFloat16Test) -ARMNN_AUTO_TEST_CASE(Gather1dParamsUint8, Gather1dParamsUint8Test) -ARMNN_AUTO_TEST_CASE(Gather1dParamsInt16, Gather1dParamsInt16Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsFloat32, GatherMultiDimParamsFloat32Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsFloat16, GatherMultiDimParamsFloat16Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsUint8, GatherMultiDimParamsUint8Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsInt16, GatherMultiDimParamsInt16Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsMultiDimIndicesFloat32, GatherMultiDimParamsMultiDimIndicesFloat32Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsMultiDimIndicesFloat16, GatherMultiDimParamsMultiDimIndicesFloat16Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsMultiDimIndicesUint8, GatherMultiDimParamsMultiDimIndicesUint8Test) -ARMNN_AUTO_TEST_CASE(GatherMultiDimParamsMultiDimIndicesInt16, GatherMultiDimParamsMultiDimIndicesInt16Test) - -// Abs -ARMNN_AUTO_TEST_CASE(Abs2d, Abs2dTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(Abs3d, Abs3dTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(AbsZero, AbsZeroTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(Abs2dFloat16, Abs2dTest<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(Abs3dFloat16, Abs3dTest<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(Abs2dQuantisedAsymm8, Abs2dTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(Abs3dQuantisedAsymm8, Abs3dTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(Abs2dQuantisedSymm16, Abs2dTest<DataType::QSymmS16>) -ARMNN_AUTO_TEST_CASE(Abs3dQuantisedSymm16, Abs3dTest<DataType::QSymmS16>) - -// Detection PostProcess -BOOST_AUTO_TEST_CASE(DetectionPostProcessRegularNmsFloat) -{ - DetectionPostProcessRegularNmsFloatTest<RefWorkloadFactory>(); -} -BOOST_AUTO_TEST_CASE(DetectionPostProcessFastNmsFloat) -{ - DetectionPostProcessFastNmsFloatTest<RefWorkloadFactory>(); -} -BOOST_AUTO_TEST_CASE(DetectionPostProcessRegularNmsUint8) -{ - DetectionPostProcessRegularNmsQuantizedTest< - RefWorkloadFactory, DataType::QAsymmU8>(); -} -BOOST_AUTO_TEST_CASE(DetectionPostProcessFastNmsUint8) -{ - DetectionPostProcessRegularNmsQuantizedTest< - RefWorkloadFactory, DataType::QAsymmU8>(); -} -BOOST_AUTO_TEST_CASE(DetectionPostProcessRegularNmsInt16) -{ - DetectionPostProcessRegularNmsQuantizedTest< - RefWorkloadFactory, DataType::QSymmS16>(); -} -BOOST_AUTO_TEST_CASE(DetectionPostProcessFastNmsInt16) -{ - DetectionPostProcessFastNmsQuantizedTest< - RefWorkloadFactory, DataType::QSymmS16>(); -} - -// Dequantize -ARMNN_AUTO_TEST_CASE(DequantizeSimpleUint8, DequantizeSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(DequantizeOffsetUint8, DequantizeOffsetUint8Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleAsymmInt8, DequantizeSimpleAsymmInt8Test) -ARMNN_AUTO_TEST_CASE(DequantizeOffsetAsymmInt8, DequantizeOffsetAsymmInt8Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt8, DequantizeSimpleInt8Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt16, DequantizeSimpleInt16Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleUint8ToFp16, DequantizeSimpleUint8ToFp16Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt8ToFp16, DequantizeSimpleInt8ToFp16Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt16ToFp16, DequantizeSimpleInt16ToFp16Test) - -// Quantize -ARMNN_AUTO_TEST_CASE(QuantizeSimpleUint8, QuantizeSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(QuantizeClampUint8, QuantizeClampUint8Test) -ARMNN_AUTO_TEST_CASE(QuantizeClampAsymmInt8, QuantizeClampAsymmInt8Test) -ARMNN_AUTO_TEST_CASE(QuantizeClampInt8, QuantizeClampInt8Test) -ARMNN_AUTO_TEST_CASE(QuantizeClampInt16, QuantizeClampInt16Test) - -// PReLU -ARMNN_AUTO_TEST_CASE(PreluFloat32, PreluTest<DataType::Float32>) -ARMNN_AUTO_TEST_CASE(PreluFloat16, PreluTest<DataType::Float16>) -ARMNN_AUTO_TEST_CASE(PreluUint8, PreluTest<DataType::QAsymmU8>) -ARMNN_AUTO_TEST_CASE(PreluInt16, PreluTest<DataType::QSymmS16>) - -// Slice -ARMNN_AUTO_TEST_CASE(Slice4dFloat32, Slice4dFloat32Test) -ARMNN_AUTO_TEST_CASE(Slice3dFloat32, Slice3dFloat32Test) -ARMNN_AUTO_TEST_CASE(Slice2dFloat32, Slice2dFloat32Test) -ARMNN_AUTO_TEST_CASE(Slice1dFloat32, Slice1dFloat32Test) - -ARMNN_AUTO_TEST_CASE(Slice4dUint8, Slice4dUint8Test) -ARMNN_AUTO_TEST_CASE(Slice3dUint8, Slice3dUint8Test) -ARMNN_AUTO_TEST_CASE(Slice2dUint8, Slice2dUint8Test) -ARMNN_AUTO_TEST_CASE(Slice1dUint8, Slice1dUint8Test) - -ARMNN_AUTO_TEST_CASE(Slice4dInt16, Slice4dInt16Test) -ARMNN_AUTO_TEST_CASE(Slice3dInt16, Slice3dInt16Test) -ARMNN_AUTO_TEST_CASE(Slice2dInt16, Slice2dInt16Test) -ARMNN_AUTO_TEST_CASE(Slice1dInt16, Slice1dInt16Test) - -// TransposeConvolution2d -ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNchw, - SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNhwc, - SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nchw, - SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nhwc, - SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dInt16Nchw, - SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dInt16Nhwc, - SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNchw, - SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNhwc, - SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nchw, - SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nhwc, - SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dInt16Nchw, - SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dInt16Nhwc, - SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNchw, - PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNhwc, - PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nchw, - PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nhwc, - PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dInt16Nchw, - PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dInt16Nhwc, - PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNchw, - PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNhwc, - PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nchw, - PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nhwc, - PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt16Nchw, - PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt16Nhwc, - PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNchw, - StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNhwc, - StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nchw, - StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nhwc, - StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dInt16Nchw, - StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dInt16Nhwc, - StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNchw, - StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNhwc, - StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nchw, - StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nhwc, - StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dInt16Nchw, - StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dInt16Nhwc, - StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - true, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNchw, - MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNhwc, - MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nchw, - MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nhwc, - MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dInt16Nchw, - MultiChannelTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dInt16Nhwc, - MultiChannelTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE(TransposeConvolution2dPerAxisQuantTestNchw, - TransposeConvolution2dPerAxisQuantTest, - DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(TransposeConvolution2dPerAxisQuantTestNhwc, - TransposeConvolution2dPerAxisQuantTest, - DataLayout::NHWC); - -// Stack -ARMNN_AUTO_TEST_CASE(Stack0Axis, StackAxis0Float32Test) -ARMNN_AUTO_TEST_CASE(StackOutput4DAxis1, StackOutput4DAxis1Float32Test) -ARMNN_AUTO_TEST_CASE(StackOutput4DAxis2, StackOutput4DAxis2Float32Test) -ARMNN_AUTO_TEST_CASE(StackOutput4DAxis3, StackOutput4DAxis3Float32Test) -ARMNN_AUTO_TEST_CASE(StackOutput3DInputs3, StackOutput3DInputs3Float32Test) -ARMNN_AUTO_TEST_CASE(StackOutput5D, StackOutput5DFloat32Test) -ARMNN_AUTO_TEST_CASE(StackFloat16, StackFloat16Test) - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefMemoryManagerTests.cpp b/src/backends/reference/test/RefMemoryManagerTests.cpp deleted file mode 100644 index 15b7c2af4f..0000000000 --- a/src/backends/reference/test/RefMemoryManagerTests.cpp +++ /dev/null @@ -1,51 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <reference/RefMemoryManager.hpp> - -#include <boost/test/unit_test.hpp> - -BOOST_AUTO_TEST_SUITE(RefMemoryManagerTests) -using namespace armnn; -using Pool = RefMemoryManager::Pool; - -BOOST_AUTO_TEST_CASE(ManageOneThing) -{ - RefMemoryManager memoryManager; - - Pool* pool = memoryManager.Manage(10); - - BOOST_CHECK(pool); - - memoryManager.Acquire(); - - BOOST_CHECK(memoryManager.GetPointer(pool) != nullptr); // Yields a valid pointer - - memoryManager.Release(); -} - -BOOST_AUTO_TEST_CASE(ManageTwoThings) -{ - RefMemoryManager memoryManager; - - Pool* pool1 = memoryManager.Manage(10); - Pool* pool2 = memoryManager.Manage(5); - - BOOST_CHECK(pool1); - BOOST_CHECK(pool2); - - memoryManager.Acquire(); - - void *p1 = memoryManager.GetPointer(pool1); - void *p2 = memoryManager.GetPointer(pool2); - - BOOST_CHECK(p1); - BOOST_CHECK(p2); - BOOST_CHECK(p1 != p2); - - memoryManager.Release(); -} - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefOptimizedNetworkTests.cpp b/src/backends/reference/test/RefOptimizedNetworkTests.cpp deleted file mode 100644 index d430f251a4..0000000000 --- a/src/backends/reference/test/RefOptimizedNetworkTests.cpp +++ /dev/null @@ -1,196 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <Graph.hpp> -#include <Network.hpp> - -#include <reference/RefWorkloadFactory.hpp> - -#include <boost/test/unit_test.hpp> -#include <test/GraphUtils.hpp> - -BOOST_AUTO_TEST_SUITE(RefOptimizedNetwork) - -BOOST_AUTO_TEST_CASE(OptimizeValidateCpuRefWorkloads) -{ - const armnn::TensorInfo desc({3, 5}, armnn::DataType::Float32); - - armnn::Network net; - - armnn::NormalizationDescriptor nmDesc; - armnn::ActivationDescriptor acDesc; - - // in - // | - // nm - // / | - // ac | - // \ | - // ml - // | - // sm - // | - // ot - armnn::IConnectableLayer* layer = net.AddInputLayer(0, "in"); - layer->GetOutputSlot(0).SetTensorInfo(desc); - - armnn::IConnectableLayer* const normLayer = net.AddNormalizationLayer(nmDesc, "nm"); - - layer->GetOutputSlot(0).Connect(normLayer->GetInputSlot(0)); - normLayer->GetOutputSlot(0).SetTensorInfo(desc); - - layer = net.AddActivationLayer(acDesc, "ac"); - - normLayer->GetOutputSlot(0).Connect(layer->GetInputSlot(0)); - layer->GetOutputSlot(0).SetTensorInfo(desc); - - armnn::IConnectableLayer* prevLayer = layer; - layer = net.AddMultiplicationLayer("ml"); - - prevLayer->GetOutputSlot(0).Connect(layer->GetInputSlot(0)); - normLayer->GetOutputSlot(0).Connect(layer->GetInputSlot(1)); - layer->GetOutputSlot(0).SetTensorInfo(desc); - - prevLayer = layer; - armnn::SoftmaxDescriptor softmaxDescriptor; - layer = net.AddSoftmaxLayer(softmaxDescriptor, "sm"); - - prevLayer->GetOutputSlot(0).Connect(layer->GetInputSlot(0)); - layer->GetOutputSlot(0).SetTensorInfo(desc); - - prevLayer = layer; - layer = net.AddOutputLayer(0, "ot"); - - prevLayer->GetOutputSlot(0).Connect(layer->GetInputSlot(0)); - - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef }; - armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(net, backends, runtime->GetDeviceSpec()); - static_cast<armnn::OptimizedNetwork*>(optNet.get())->GetGraph().AllocateDynamicBuffers(); - BOOST_CHECK(optNet); - - // Validates workloads. - armnn::RefWorkloadFactory fact; - for (auto&& layer : static_cast<armnn::OptimizedNetwork*>(optNet.get())->GetGraph()) - { - BOOST_CHECK_NO_THROW(layer->CreateWorkload(fact)); - } -} - -BOOST_AUTO_TEST_CASE(OptimizeValidateWorkloadsCpuRefPermuteLayer) -{ - // Create runtime in which test will run - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; - - // build up the structure of the network - armnn::INetworkPtr net(armnn::INetwork::Create()); - - armnn::IConnectableLayer* input = net->AddInputLayer(0); - - armnn::PermuteDescriptor descriptor({0, 2, 3, 1}); - armnn::IConnectableLayer* permute = net->AddPermuteLayer(descriptor); - - armnn::IConnectableLayer* output = net->AddOutputLayer(0); - - input->GetOutputSlot(0).Connect(permute->GetInputSlot(0)); - permute->GetOutputSlot(0).Connect(output->GetInputSlot(0)); - - input->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo({ 1, 1, 4, 4 }, armnn::DataType::Float32)); - permute->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo({ 1, 4, 1, 4 }, armnn::DataType::Float32)); - - // optimize the network - armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec()); - - for (auto&& layer : static_cast<armnn::OptimizedNetwork*>(optNet.get())->GetGraph()) - { - BOOST_CHECK(layer->GetBackendId() == armnn::Compute::CpuRef); - } -} - -BOOST_AUTO_TEST_CASE(OptimizeValidateWorkloadsCpuRefMeanLayer) -{ - // Create runtime in which test will run - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; - - // build up the structure of the network - armnn::INetworkPtr net(armnn::INetwork::Create()); - - armnn::IConnectableLayer* input = net->AddInputLayer(0); - - armnn::MeanDescriptor descriptor({ 0, 1 }, false); - armnn::IConnectableLayer* meanLayer = net->AddMeanLayer(descriptor); - - armnn::IConnectableLayer* output = net->AddOutputLayer(0); - - input->GetOutputSlot(0).Connect(meanLayer->GetInputSlot(0)); - meanLayer->GetOutputSlot(0).Connect(output->GetInputSlot(0)); - - input->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo({ 4, 3, 2 }, armnn::DataType::Float32)); - meanLayer->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo({ 2 }, armnn::DataType::Float32)); - - // optimize the network - armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec()); - - for (auto&& layer : static_cast<armnn::OptimizedNetwork*>(optNet.get())->GetGraph()) - { - BOOST_CHECK(layer->GetBackendId() == armnn::Compute::CpuRef); - } -} - -BOOST_AUTO_TEST_CASE(DebugTestOnCpuRef) -{ - armnn::Network net; - - armnn::ActivationDescriptor activation1Descriptor; - activation1Descriptor.m_Function = armnn::ActivationFunction::BoundedReLu; - activation1Descriptor.m_A = 1.f; - activation1Descriptor.m_B = -1.f; - - // Defines layers. - auto input = net.AddInputLayer(0, "InputLayer"); - auto activation = net.AddActivationLayer(activation1Descriptor, "ActivationLayer"); - auto output = net.AddOutputLayer(0, "OutputLayer"); - - // Connects layers. - input->GetOutputSlot(0).Connect(activation->GetInputSlot(0)); - activation->GetOutputSlot(0).Connect(output->GetInputSlot(0)); - - armnn::TensorShape shape({4}); - armnn::TensorInfo info(shape, armnn::DataType::Float32); - input->GetOutputSlot(0).SetTensorInfo(info); - activation->GetOutputSlot(0).SetTensorInfo(info); - - armnn::IRuntime::CreationOptions options; - armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options)); - - std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; - - armnn::OptimizerOptions optimizerOptions; - optimizerOptions.m_Debug = true; - - armnn::IOptimizedNetworkPtr optimizedNet = armnn::Optimize(net, backends, runtime->GetDeviceSpec(), - optimizerOptions); - - const armnn::Graph& graph = static_cast<armnn::OptimizedNetwork*>(optimizedNet.get())->GetGraph(); - // Tests that all layers are present in the graph. - BOOST_TEST(graph.GetNumLayers() == 5); - - // Tests that the vertices exist and have correct names. - BOOST_TEST(GraphHasNamedLayer(graph, "InputLayer")); - BOOST_TEST(GraphHasNamedLayer(graph, "DebugLayerAfterInputLayer")); - BOOST_TEST(GraphHasNamedLayer(graph, "ActivationLayer")); - BOOST_TEST(GraphHasNamedLayer(graph, "DebugLayerAfterActivationLayer")); - BOOST_TEST(GraphHasNamedLayer(graph, "OutputLayer")); -} - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefRuntimeTests.cpp b/src/backends/reference/test/RefRuntimeTests.cpp deleted file mode 100644 index ae49366c62..0000000000 --- a/src/backends/reference/test/RefRuntimeTests.cpp +++ /dev/null @@ -1,46 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include <test/RuntimeTests.hpp> - -#include <LeakChecking.hpp> - -#include <backendsCommon/test/RuntimeTestImpl.hpp> - -#include <boost/test/unit_test.hpp> - -BOOST_AUTO_TEST_SUITE(RefRuntime) - -#ifdef ARMNN_LEAK_CHECKING_ENABLED -BOOST_AUTO_TEST_CASE(RuntimeMemoryLeaksCpuRef) -{ - BOOST_TEST(ARMNN_LEAK_CHECKER_IS_ACTIVE()); - - armnn::IRuntime::CreationOptions options; - armnn::Runtime runtime(options); - armnn::RuntimeLoadedNetworksReserve(&runtime); - - std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; - { - // Do a warmup of this so we make sure that all one-time - // initialization happens before we do the leak checking. - CreateAndDropDummyNetwork(backends, runtime); - } - - { - ARMNN_SCOPED_LEAK_CHECKER("LoadAndUnloadNetworkCpuRef"); - BOOST_TEST(ARMNN_NO_LEAKS_IN_SCOPE()); - // In the second run we check for all remaining memory - // in use after the network was unloaded. If there is any - // then it will be treated as a memory leak. - CreateAndDropDummyNetwork(backends, runtime); - BOOST_TEST(ARMNN_NO_LEAKS_IN_SCOPE()); - BOOST_TEST(ARMNN_BYTES_LEAKED_IN_SCOPE() == 0); - BOOST_TEST(ARMNN_OBJECTS_LEAKED_IN_SCOPE() == 0); - } -} -#endif - -BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file diff --git a/src/backends/reference/test/RefTensorHandleTests.cpp b/src/backends/reference/test/RefTensorHandleTests.cpp deleted file mode 100644 index be229bf844..0000000000 --- a/src/backends/reference/test/RefTensorHandleTests.cpp +++ /dev/null @@ -1,108 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#include <reference/RefTensorHandle.hpp> - -#include <boost/test/unit_test.hpp> - -BOOST_AUTO_TEST_SUITE(RefTensorHandleTests) -using namespace armnn; - -BOOST_AUTO_TEST_CASE(AcquireAndRelease) -{ - std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>(); - - TensorInfo info({1,1,1,1}, DataType::Float32); - RefTensorHandle handle(info, memoryManager); - - handle.Manage(); - handle.Allocate(); - - memoryManager->Acquire(); - { - float *buffer = reinterpret_cast<float *>(handle.Map()); - - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer - - buffer[0] = 2.5f; - - BOOST_CHECK(buffer[0] == 2.5f); // Memory is writable and readable - - } - memoryManager->Release(); - - memoryManager->Acquire(); - { - float *buffer = reinterpret_cast<float *>(handle.Map()); - - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer - - buffer[0] = 3.5f; - - BOOST_CHECK(buffer[0] == 3.5f); // Memory is writable and readable - } - memoryManager->Release(); -} - -#if !defined(__ANDROID__) -// Only run these tests on non Android platforms -BOOST_AUTO_TEST_CASE(CheckSourceType) -{ - std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>(); - - TensorInfo info({1}, DataType::Float32); - RefTensorHandle handle(info, memoryManager, static_cast<unsigned int>(MemorySource::Malloc)); - - int* testPtr = new int(4); - - // Not supported - BOOST_CHECK(!handle.Import(static_cast<void *>(testPtr), MemorySource::DmaBuf)); - - // Not supported - BOOST_CHECK(!handle.Import(static_cast<void *>(testPtr), MemorySource::DmaBufProtected)); - - // Supported - BOOST_CHECK(handle.Import(static_cast<void *>(testPtr), MemorySource::Malloc)); - - delete testPtr; -} - -BOOST_AUTO_TEST_CASE(ReusePointer) -{ - std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>(); - - TensorInfo info({1}, DataType::Float32); - RefTensorHandle handle(info, memoryManager, static_cast<unsigned int>(MemorySource::Malloc)); - - int* testPtr = new int(4); - - handle.Import(static_cast<void *>(testPtr), MemorySource::Malloc); - - // Reusing previously Imported pointer - BOOST_CHECK(handle.Import(static_cast<void *>(testPtr), MemorySource::Malloc)); - - delete testPtr; -} - -BOOST_AUTO_TEST_CASE(MisalignedPointer) -{ - std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>(); - - TensorInfo info({2}, DataType::Float32); - RefTensorHandle handle(info, memoryManager, static_cast<unsigned int>(MemorySource::Malloc)); - - // Allocate a 2 int array - int* testPtr = new int[2]; - - // Increment pointer by 1 byte - void* misalignedPtr = static_cast<void*>(reinterpret_cast<char*>(testPtr) + 1); - - BOOST_CHECK(!handle.Import(misalignedPtr, MemorySource::Malloc)); - - delete[] testPtr; -} - -#endif - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefWorkloadFactoryHelper.hpp b/src/backends/reference/test/RefWorkloadFactoryHelper.hpp deleted file mode 100644 index 10e5b9fa28..0000000000 --- a/src/backends/reference/test/RefWorkloadFactoryHelper.hpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/test/WorkloadFactoryHelper.hpp> - -#include <reference/RefBackend.hpp> -#include <reference/RefWorkloadFactory.hpp> - -namespace -{ - -template<> -struct WorkloadFactoryHelper<armnn::RefWorkloadFactory> -{ - static armnn::IBackendInternal::IMemoryManagerSharedPtr GetMemoryManager() - { - armnn::RefBackend backend; - return backend.CreateMemoryManager(); - } - - static armnn::RefWorkloadFactory GetFactory( - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr) - { - boost::ignore_unused(memoryManager); - return armnn::RefWorkloadFactory(); - } -}; - -using RefWorkloadFactoryHelper = WorkloadFactoryHelper<armnn::RefWorkloadFactory>; - -} // anonymous namespace diff --git a/src/backends/reference/workloads/Abs.hpp b/src/backends/reference/workloads/Abs.hpp deleted file mode 100644 index b05f2e3367..0000000000 --- a/src/backends/reference/workloads/Abs.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <iostream> - -namespace armnn -{ - template<typename T> -struct abs : public std::unary_function<T, T> - { - T - operator () (const T& inputData) const - { - return std::abs(inputData); - } - }; - -} //namespace armnn diff --git a/src/backends/reference/workloads/Activation.cpp b/src/backends/reference/workloads/Activation.cpp deleted file mode 100644 index 814a0ddd13..0000000000 --- a/src/backends/reference/workloads/Activation.cpp +++ /dev/null @@ -1,101 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Activation.hpp" - -#include <cmath> - -namespace armnn -{ -float Activation(float in, - ActivationFunction function, - float a, - float b) -{ - float output; - - // Compute the result of the activation function. - switch (function) - { - case ActivationFunction::Linear: - { - output = a * in + b; - break; - } - case ActivationFunction::Sigmoid: - { - output = 1.f / (1.f + expf(-in)); - break; - } - case ActivationFunction::ReLu: - { - output = std::max(0.f, in); - break; - } - case ActivationFunction::BoundedReLu: - { - output = std::min(a, std::max(b, in)); - break; - } - case ActivationFunction::SoftReLu: - { - output = logf(1.0f + expf(in)); - break; - } - case ActivationFunction::LeakyReLu: - { - output = in > 0.0f ? in : (in * a); - break; - } - case ActivationFunction::Abs: - { - output = in < 0 ? -in : in; - break; - } - case ActivationFunction::Sqrt: - { - output = sqrtf(in); - break; - } - case ActivationFunction::Square: - { - output = in * in; - break; - } - case ActivationFunction::TanH: - { - output = a * tanhf(b * in); - break; - } - default: - { - throw InvalidArgumentException("Unsupported activation function"); - } - } - - return output; -} - - -void Activation(Decoder<float>& in, - Encoder<float>& out, - const TensorInfo& tensorInfo, - ActivationFunction function, - float a, - float b) -{ - unsigned int numElements = tensorInfo.GetNumElements(); - - for (unsigned int i = 0; i < numElements; i++) - { - out.Set(Activation(in.Get(), function, a, b)); - ++in; - ++out; - } - in -= numElements; - out -= numElements; -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/Activation.hpp b/src/backends/reference/workloads/Activation.hpp deleted file mode 100644 index b7fd50c54c..0000000000 --- a/src/backends/reference/workloads/Activation.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "BaseIterator.hpp" - -#include <armnn/Tensor.hpp> -#include <armnn/Types.hpp> - -namespace armnn -{ -float Activation(float in, - ActivationFunction function, - float a, - float b); - -void Activation(Decoder<float>& in, - Encoder<float>& out, - const TensorInfo& tensorInfo, - ActivationFunction function, - float a, - float b); - -} //namespace armnn diff --git a/src/backends/reference/workloads/ArgMinMax.cpp b/src/backends/reference/workloads/ArgMinMax.cpp deleted file mode 100644 index db85b958e9..0000000000 --- a/src/backends/reference/workloads/ArgMinMax.cpp +++ /dev/null @@ -1,47 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "ArgMinMax.hpp" - -#include <armnnUtils/TensorUtils.hpp> - -#include <boost/numeric/conversion/cast.hpp> - -namespace armnn -{ - -void ArgMinMax(Decoder<float>& in, int32_t* out, const TensorInfo& inputTensorInfo, - const TensorInfo& outputTensorInfo, ArgMinMaxFunction function, int axis) -{ - boost::ignore_unused(outputTensorInfo); - - unsigned int uAxis = armnnUtils::GetUnsignedAxis(inputTensorInfo.GetNumDimensions(), axis); - - const unsigned int outerElements = armnnUtils::GetNumElementsBetween(inputTensorInfo.GetShape(), 0, uAxis); - const unsigned int axisSize = inputTensorInfo.GetShape()[uAxis]; - const unsigned int innerElements = armnnUtils::GetNumElementsBetween(inputTensorInfo.GetShape(), - uAxis + 1, - inputTensorInfo.GetNumDimensions()); - - for (unsigned int outer = 0; outer < outerElements; ++outer) { - for (unsigned int inner = 0; inner < innerElements; ++inner) { - in[outer * axisSize * innerElements + inner]; - auto tmpValue = in.Get(); - unsigned int tmpIndex = 0; - for (unsigned int i = 1; i < axisSize; ++i) { - in[(outer * axisSize * innerElements) + (i * innerElements) + inner]; - const auto& value = in.Get(); - if ((function == armnn::ArgMinMaxFunction::Min && value < tmpValue) || - (function == armnn::ArgMinMaxFunction::Max && value > tmpValue)) { - tmpValue = value; - tmpIndex = i; - } - } - out[outer * innerElements + inner] = boost::numeric_cast<int32_t>(tmpIndex); - } - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/ArgMinMax.hpp b/src/backends/reference/workloads/ArgMinMax.hpp deleted file mode 100644 index 5a9c6a8a2a..0000000000 --- a/src/backends/reference/workloads/ArgMinMax.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "armnn/Tensor.hpp" -#include "armnn/Descriptors.hpp" - -#include "Decoders.hpp" - -namespace armnn -{ - -void ArgMinMax(Decoder<float>& in, int32_t* out, const TensorInfo& inputTensorInfo, - const TensorInfo& outputTensorInfo, ArgMinMaxFunction function, int axis); - -} //namespace armnn - diff --git a/src/backends/reference/workloads/BaseIterator.hpp b/src/backends/reference/workloads/BaseIterator.hpp deleted file mode 100644 index c48201837b..0000000000 --- a/src/backends/reference/workloads/BaseIterator.hpp +++ /dev/null @@ -1,573 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - - -#include <armnn/TypesUtils.hpp> -#include <armnnUtils/FloatingPointConverter.hpp> - -#include <ResolveType.hpp> - -#include <boost/assert.hpp> -#include <boost/core/ignore_unused.hpp> - -namespace armnn -{ - -class BaseIterator -{ -public: - BaseIterator() {} - - virtual ~BaseIterator() {} - - virtual BaseIterator& SetIndex(unsigned int index, unsigned int axisIndex = 0) = 0; - - virtual BaseIterator& operator++() = 0; - - virtual BaseIterator& operator+=(const unsigned int increment) = 0; - - virtual BaseIterator& operator-=(const unsigned int increment) = 0; - - virtual BaseIterator& operator[](const unsigned int index) = 0; -}; - -template<typename IType> -class Decoder : public BaseIterator -{ -public: - Decoder() {} - - virtual ~Decoder() {} - - virtual void Reset(void*) = 0; - - virtual IType Get() const = 0; -}; - -template<typename IType> -class Encoder : public BaseIterator -{ -public: - Encoder() {} - - virtual ~Encoder() {} - - virtual void Reset(void*) = 0; - - virtual void Set(IType right) = 0; - - virtual IType Get() const = 0; -}; - -template<typename T, typename Base> -class TypedIterator : public Base -{ -public: - TypedIterator(T* data = nullptr) - : m_Iterator(data), m_Start(data) - {} - - void Reset(void* data) override - { - m_Iterator = reinterpret_cast<T*>(data); - m_Start = m_Iterator; - } - - TypedIterator& operator++() override - { - BOOST_ASSERT(m_Iterator); - ++m_Iterator; - return *this; - } - - TypedIterator& operator+=(const unsigned int increment) override - { - BOOST_ASSERT(m_Iterator); - m_Iterator += increment; - return *this; - } - - TypedIterator& operator-=(const unsigned int increment) override - { - BOOST_ASSERT(m_Iterator); - m_Iterator -= increment; - return *this; - } - - TypedIterator& operator[](const unsigned int index) override - { - BOOST_ASSERT(m_Iterator); - m_Iterator = m_Start + index; - return *this; - } - - TypedIterator& SetIndex(unsigned int index, unsigned int axisIndex = 0) override - { - boost::ignore_unused(axisIndex); - BOOST_ASSERT(m_Iterator); - m_Iterator = m_Start + index; - return *this; - } - -protected: - T* m_Iterator; - T* m_Start; -}; - -class QASymm8Decoder : public TypedIterator<const uint8_t, Decoder<float>> -{ -public: - QASymm8Decoder(const uint8_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QASymm8Decoder(const float scale, const int32_t offset) - : QASymm8Decoder(nullptr, scale, offset) {} - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class QASymmS8Decoder : public TypedIterator<const int8_t, Decoder<float>> -{ -public: - QASymmS8Decoder(const int8_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QASymmS8Decoder(const float scale, const int32_t offset) - : QASymmS8Decoder(nullptr, scale, offset) {} - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class QSymmS8Decoder : public TypedIterator<const int8_t, Decoder<float>> -{ -public: - QSymmS8Decoder(const int8_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QSymmS8Decoder(const float scale, const int32_t offset) - : QSymmS8Decoder(nullptr, scale, offset) {} - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class QSymm16Decoder : public TypedIterator<const int16_t, Decoder<float>> -{ -public: - QSymm16Decoder(const int16_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QSymm16Decoder(const float scale, const int32_t offset) - : QSymm16Decoder(nullptr, scale, offset) {} - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class Float16Decoder : public TypedIterator<const Half, Decoder<float>> -{ -public: - Float16Decoder(const Half* data) - : TypedIterator(data) {} - - Float16Decoder() - : Float16Decoder(nullptr) {} - - float Get() const override - { - float val = 0.f; - armnnUtils::FloatingPointConverter::ConvertFloat16To32(m_Iterator, 1, &val); - return val; - } -}; - -class Float32Decoder : public TypedIterator<const float, Decoder<float>> -{ -public: - Float32Decoder(const float* data) - : TypedIterator(data) {} - - Float32Decoder() - : Float32Decoder(nullptr) {} - - float Get() const override - { - return *m_Iterator; - } -}; - -class ScaledInt32Decoder : public TypedIterator<const int32_t, Decoder<float>> -{ -public: - ScaledInt32Decoder(const int32_t* data, const float scale) - : TypedIterator(data), m_Scale(scale) {} - - ScaledInt32Decoder(const float scale) - : ScaledInt32Decoder(nullptr, scale) {} - - float Get() const override - { - return static_cast<float>(*m_Iterator) * m_Scale; - } - -private: - const float m_Scale; -}; - -class Int32Decoder : public TypedIterator<const int32_t, Decoder<float>> -{ -public: - Int32Decoder(const int32_t* data) - : TypedIterator(data) {} - - Int32Decoder() - : Int32Decoder(nullptr) {} - - float Get() const override - { - return static_cast<float>(*m_Iterator); - } -}; - -class QASymm8Encoder : public TypedIterator<uint8_t, Encoder<float>> -{ -public: - QASymm8Encoder(uint8_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QASymm8Encoder(const float scale, const int32_t offset) - : QASymm8Encoder(nullptr, scale, offset) {} - - void Set(float right) override - { - *m_Iterator = armnn::Quantize<uint8_t>(right, m_Scale, m_Offset); - } - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class QASymmS8Encoder : public TypedIterator<int8_t, Encoder<float>> -{ -public: - QASymmS8Encoder(int8_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QASymmS8Encoder(const float scale, const int32_t offset) - : QASymmS8Encoder(nullptr, scale, offset) {} - - void Set(float right) override - { - *m_Iterator = armnn::Quantize<int8_t>(right, m_Scale, m_Offset); - } - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class QSymmS8Encoder : public TypedIterator<int8_t, Encoder<float>> -{ -public: - QSymmS8Encoder(int8_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QSymmS8Encoder(const float scale, const int32_t offset) - : QSymmS8Encoder(nullptr, scale, offset) {} - - void Set(float right) override - { - *m_Iterator = armnn::Quantize<int8_t>(right, m_Scale, m_Offset); - } - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class QSymm16Encoder : public TypedIterator<int16_t, Encoder<float>> -{ -public: - QSymm16Encoder(int16_t* data, const float scale, const int32_t offset) - : TypedIterator(data), m_Scale(scale), m_Offset(offset) {} - - QSymm16Encoder(const float scale, const int32_t offset) - : QSymm16Encoder(nullptr, scale, offset) {} - - void Set(float right) override - { - *m_Iterator = armnn::Quantize<int16_t>(right, m_Scale, m_Offset); - } - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale, m_Offset); - } - -private: - const float m_Scale; - const int32_t m_Offset; -}; - -class Float16Encoder : public TypedIterator<Half, Encoder<float>> -{ -public: - Float16Encoder(Half* data) - : TypedIterator(data) {} - - Float16Encoder() - : Float16Encoder(nullptr) {} - - void Set(float right) override - { - armnnUtils::FloatingPointConverter::ConvertFloat32To16(&right, 1, m_Iterator); - } - - float Get() const override - { - float val = 0.f; - armnnUtils::FloatingPointConverter::ConvertFloat16To32(m_Iterator, 1, &val); - return val; - } -}; - -class Float32Encoder : public TypedIterator<float, Encoder<float>> -{ -public: - Float32Encoder(float* data) - : TypedIterator(data) {} - - Float32Encoder() - : Float32Encoder(nullptr) {} - - void Set(float right) override - { - *m_Iterator = right; - } - - float Get() const override - { - return *m_Iterator; - } -}; - -class Int32Encoder : public TypedIterator<int32_t, Encoder<float>> -{ -public: - Int32Encoder(int32_t* data) - : TypedIterator(data) {} - - Int32Encoder() - : Int32Encoder(nullptr) {} - - void Set(float right) override - { - *m_Iterator = static_cast<int32_t>(right); - } - - float Get() const override - { - return static_cast<float>(*m_Iterator); - } -}; - -class BooleanEncoder : public TypedIterator<uint8_t, Encoder<bool>> -{ -public: - BooleanEncoder(uint8_t* data) - : TypedIterator(data) {} - - BooleanEncoder() - : BooleanEncoder(nullptr) {} - - void Set(bool right) override - { - *m_Iterator = right; - } - - bool Get() const override - { - return *m_Iterator; - } -}; - -// PerAxisIterator for per-axis quantization -template<typename T, typename Base> -class PerAxisIterator : public Base -{ -public: - // axisFactor is used to calculate axisIndex - PerAxisIterator(T* data = nullptr, unsigned int axisFactor = 0) - : m_Iterator(data), m_Start(data), m_AxisIndex(0), m_AxisFactor(axisFactor) - {} - - // This should be called to set index for per-axis Encoder/Decoder - PerAxisIterator& SetIndex(unsigned int index, unsigned int axisIndex) override - { - BOOST_ASSERT(m_Iterator); - m_Iterator = m_Start + index; - m_AxisIndex = axisIndex; - return *this; - } - - void Reset(void* data) override - { - m_Iterator = reinterpret_cast<T*>(data); - m_Start = m_Iterator; - m_AxisIndex = 0; - } - - PerAxisIterator& operator++() override - { - BOOST_ASSERT(m_Iterator); - ++m_Iterator; - m_AxisIndex = static_cast<unsigned int>(*m_Iterator) % m_AxisFactor; - return *this; - } - - PerAxisIterator& operator+=(const unsigned int increment) override - { - BOOST_ASSERT(m_Iterator); - m_Iterator += increment; - m_AxisIndex = static_cast<unsigned int>(*m_Iterator) % m_AxisFactor; - return *this; - } - - PerAxisIterator& operator-=(const unsigned int decrement) override - { - BOOST_ASSERT(m_Iterator); - m_Iterator -= decrement; - m_AxisIndex = static_cast<unsigned int>(*m_Iterator) % m_AxisFactor; - return *this; - } - - PerAxisIterator& operator[](const unsigned int index) override - { - BOOST_ASSERT(m_Iterator); - m_Iterator = m_Start + index; - m_AxisIndex = static_cast<unsigned int>(*m_Iterator) % m_AxisFactor; - return *this; - } - - protected: - T* m_Iterator; - T* m_Start; - unsigned int m_AxisIndex; - unsigned int m_AxisFactor; -}; - -class QSymm8PerAxisDecoder : public PerAxisIterator<const int8_t, Decoder<float>> -{ -public: - QSymm8PerAxisDecoder(const int8_t* data, const std::vector<float>& scale, unsigned int axisFactor) - : PerAxisIterator(data, axisFactor), m_Scale(scale) {} - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scale[m_AxisIndex], 0); - } - - // Get scale of the current value - float GetScale() const - { - return m_Scale[m_AxisIndex]; - } - -private: - std::vector<float> m_Scale; -}; - -class QSymm8PerAxisEncoder : public PerAxisIterator<int8_t, Encoder<float>> -{ -public: - QSymm8PerAxisEncoder(int8_t* data, const std::vector<float>& scale, unsigned int axisFactor) - : PerAxisIterator(data, axisFactor), m_Scale(scale) {} - - void Set(float right) - { - *m_Iterator = armnn::Quantize<int8_t>(right, m_Scale[m_AxisIndex], 0); - } - - float Get() const - { - return armnn::Dequantize(*m_Iterator, m_Scale[m_AxisIndex], 0); - } - - // Get scale of the current value - float GetScale() const - { - return m_Scale[m_AxisIndex]; - } - -private: - std::vector<float> m_Scale; -}; - -class ScaledInt32PerAxisDecoder : public PerAxisIterator<const int32_t, Decoder<float>> -{ -public: - ScaledInt32PerAxisDecoder(const int32_t* data, const std::vector<float>& scales, unsigned int axisFactor) - : PerAxisIterator(data, axisFactor), m_Scales(scales) {} - - float Get() const override - { - return armnn::Dequantize(*m_Iterator, m_Scales[m_AxisIndex], 0); - } - - // Get scale of the current value - float GetScale() const - { - return m_Scales[m_AxisIndex]; - } - -private: - std::vector<float> m_Scales; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/BatchNormImpl.cpp b/src/backends/reference/workloads/BatchNormImpl.cpp deleted file mode 100644 index e742c7280f..0000000000 --- a/src/backends/reference/workloads/BatchNormImpl.cpp +++ /dev/null @@ -1,66 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "BatchNormImpl.hpp" -#include "RefWorkloadUtils.hpp" - -#include <armnn/Tensor.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <cmath> - -namespace armnn -{ - -void BatchNormImpl(const BatchNormalizationQueueDescriptor& data, - Decoder<float>& meanDecoder, - Decoder<float>& varianceDecoder, - Decoder<float>& betaDecoder, - Decoder<float>& gammaDecoder, - Decoder<float>& inputDecoder, - Encoder<float>& outputEncoder) -{ - const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]); - const TensorShape inputShape = inputInfo.GetShape(); - - armnnUtils::DataLayoutIndexed dataLayout(data.m_Parameters.m_DataLayout); - - unsigned int inputBatches = inputShape[0]; - unsigned int inputHeight = inputShape[dataLayout.GetHeightIndex()]; - unsigned int inputWidth = inputShape[dataLayout.GetWidthIndex()]; - unsigned int inputChannels = inputShape[dataLayout.GetChannelsIndex()]; - - for (unsigned int c = 0; c < inputChannels; c++) - { - meanDecoder[c]; - varianceDecoder[c]; - betaDecoder[c]; - gammaDecoder[c]; - float mean = meanDecoder.Get(); - float var = varianceDecoder.Get(); - float beta = betaDecoder.Get(); - float gamma = gammaDecoder.Get(); - - float mult = gamma / sqrtf(var + data.m_Parameters.m_Eps); - float add = beta - mult * mean; - - for (unsigned int n = 0; n < inputBatches; n++) - { - for (unsigned int h = 0; h < inputHeight; h++) - { - for (unsigned int w = 0; w < inputWidth; w++) - { - unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w); - inputDecoder[index]; - outputEncoder[index]; - outputEncoder.Set(mult * inputDecoder.Get() + add); - } - } - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/BatchNormImpl.hpp b/src/backends/reference/workloads/BatchNormImpl.hpp deleted file mode 100644 index c0250b9e0f..0000000000 --- a/src/backends/reference/workloads/BatchNormImpl.hpp +++ /dev/null @@ -1,24 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Encoders.hpp" -#include "Decoders.hpp" - -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -void BatchNormImpl(const BatchNormalizationQueueDescriptor& data, - Decoder<float>& meanIn, - Decoder<float>& varIn, - Decoder<float>& betaIn, - Decoder<float>& gammaIn, - Decoder<float>& inputData, - Encoder<float>& outputData); - -} // namespace armnn diff --git a/src/backends/reference/workloads/BatchToSpaceNd.cpp b/src/backends/reference/workloads/BatchToSpaceNd.cpp deleted file mode 100644 index 7efdb9b75c..0000000000 --- a/src/backends/reference/workloads/BatchToSpaceNd.cpp +++ /dev/null @@ -1,103 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "BatchToSpaceNd.hpp" - -#include "RefWorkloadUtils.hpp" - -#include <armnn/Types.hpp> - -#include <boost/assert.hpp> - -using namespace armnnUtils; - -namespace armnn -{ - -inline unsigned int Offset(const TensorShape& shape, unsigned int batch, unsigned int height, unsigned int width, - unsigned int channels, const DataLayoutIndexed& dataLayout) -{ - if (dataLayout.GetDataLayout() == DataLayout::NHWC) - { - return ((batch * shape[dataLayout.GetHeightIndex()] + height) * shape[dataLayout.GetWidthIndex()] + width) * - shape[dataLayout.GetChannelsIndex()] + channels; - } - else - { - return ((batch * shape[dataLayout.GetChannelsIndex()] + channels) * - shape[dataLayout.GetHeightIndex()] + height) * - shape[dataLayout.GetWidthIndex()] + width; - } -} - -void BatchToSpaceNd(const DataLayoutIndexed& dataLayout, - const TensorInfo& inputTensorInfo, - const TensorInfo& outputTensorInfo, - const std::vector<unsigned int>& blockShape, - const std::vector<std::pair<unsigned int, unsigned int>>& cropsData, - Decoder<float>& inputDecoder, - Encoder<float>& outputEncoder) -{ - TensorShape inputShape = inputTensorInfo.GetShape(); - - BOOST_ASSERT_MSG(inputShape.GetNumDimensions() == 4, "Expected Input with 4 Dimensions"); - - TensorShape outputShape = outputTensorInfo.GetShape(); - - BOOST_ASSERT_MSG(outputShape.GetNumDimensions() == 4, "Expected Output with 4 Dimensions"); - - const unsigned int inputBatchSize = inputShape[0]; - const unsigned int channels = inputShape[dataLayout.GetChannelsIndex()]; - - const unsigned int outputBatchSize = outputShape[0]; - const unsigned int outputHeight = outputShape[dataLayout.GetHeightIndex()]; - const unsigned int outputWidth = outputShape[dataLayout.GetWidthIndex()]; - - BOOST_ASSERT_MSG(blockShape.size() > 0, "BlockShape must contain 1 or more entries"); - - const unsigned int blockShapeHeight = blockShape[0]; - const unsigned int blockShapeWidth = blockShape[1]; - - BOOST_ASSERT_MSG(cropsData.size() > 0, "Crops must contain 1 or more entries"); - - const unsigned int cropsTop = cropsData[0].first; - const unsigned int cropsLeft = cropsData[1].first; - - for (unsigned int inBatch = 0; inBatch < inputBatchSize; ++inBatch) - { - const unsigned int outBatch = inBatch % outputBatchSize; - const unsigned int spatialOffset = inBatch / outputBatchSize; - - for (unsigned int inH = 0; inH < inputTensorInfo.GetShape()[dataLayout.GetHeightIndex()]; ++inH) { - const unsigned int outH = inH * blockShapeHeight + spatialOffset / blockShapeWidth - cropsTop; - - if (outH >= outputHeight) - { - continue; - } - - for (unsigned int inW = 0; inW < inputTensorInfo.GetShape()[dataLayout.GetWidthIndex()]; ++inW) { - const unsigned int outW = inW * blockShapeWidth + spatialOffset % blockShapeWidth - cropsLeft; - - if (outW >= outputWidth) - { - continue; - } - - for (unsigned int c = 0; c < channels; c++) - { - unsigned int outOffset = Offset(outputShape, outBatch, outH, outW, c, dataLayout); - unsigned int inOffset = Offset(inputShape, inBatch, inH, inW, c, dataLayout); - - outputEncoder[outOffset]; - inputDecoder[inOffset]; - outputEncoder.Set(inputDecoder.Get()); - } - } - } - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/BatchToSpaceNd.hpp b/src/backends/reference/workloads/BatchToSpaceNd.hpp deleted file mode 100644 index a375aaae52..0000000000 --- a/src/backends/reference/workloads/BatchToSpaceNd.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <armnn/Types.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -void BatchToSpaceNd(const armnnUtils::DataLayoutIndexed& dataLayout, - const TensorInfo& inputTensorInfo, - const TensorInfo& outputTensorInfo, - const std::vector<unsigned int>& blockShape, - const std::vector<std::pair<unsigned int, unsigned int>>& cropsData, - Decoder<float>& inputDecoder, - Encoder<float>& outputEncoder); -} // namespace armnn diff --git a/src/backends/reference/workloads/Broadcast.cpp b/src/backends/reference/workloads/Broadcast.cpp deleted file mode 100644 index 24af0fc4b1..0000000000 --- a/src/backends/reference/workloads/Broadcast.cpp +++ /dev/null @@ -1,52 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Broadcast.hpp" - -namespace armnn -{ - -BroadcastLoop::BroadcastLoop(const TensorShape& inShape0, const TensorShape& inShape1, const TensorShape& outShape) -: m_DimData(outShape.GetNumDimensions()) -{ - const unsigned int numDims = GetNumDimensions(); - - unsigned int sIn0 = 1; - unsigned int sIn1 = 1; - unsigned int sOut = 1; - - for (unsigned int j = numDims - 1, k = 0; k < numDims ; k++, j--) - { - m_DimData[j].m_DimSize = outShape[j]; - m_DimData[j].m_Stride1 = (inShape0[j] > 1) ? sIn0 : 0; - m_DimData[j].m_Stride2 = (inShape1[j] > 1) ? sIn1 : 0; - m_DimData[j].m_StrideOut = sOut; - - sIn0 *= inShape0[j]; - sIn1 *= inShape1[j]; - sOut *= outShape[j]; - } -} - -BroadcastLoop::BroadcastLoop(const TensorShape& inShape, const TensorShape& outShape) -: m_DimData(outShape.GetNumDimensions()) -{ - const unsigned int numDims = GetNumDimensions(); - - unsigned int sIn = 1; - unsigned int sOut = 1; - - for (unsigned int j = numDims - 1, k = 0; k < numDims ; k++, j--) - { - m_DimData[j].m_DimSize = outShape[j]; - m_DimData[j].m_Stride1 = (inShape[j] > 1) ? sIn : 0; - m_DimData[j].m_StrideOut = sOut; - - sIn *= inShape[j]; - sOut *= outShape[j]; - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/Broadcast.hpp b/src/backends/reference/workloads/Broadcast.hpp deleted file mode 100644 index a3d944ae75..0000000000 --- a/src/backends/reference/workloads/Broadcast.hpp +++ /dev/null @@ -1,105 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "BaseIterator.hpp" -#include <armnn/Tensor.hpp> - -#include <functional> - -namespace armnn -{ - -struct BroadcastLoop -{ - BroadcastLoop(const TensorShape& inShape0, const TensorShape& inShape1, const TensorShape& outShape); - - BroadcastLoop(const TensorShape& inShape, const TensorShape& outShape); - - unsigned int GetNumDimensions() - { - return static_cast<unsigned int>(m_DimData.size()); - } - - template <typename Func, typename DecoderOp, typename EncoderOp> - void Unroll(Func operationFunc, - unsigned int dimension, - DecoderOp& inData0, - DecoderOp& inData1, - EncoderOp& outData) - { - if (dimension >= GetNumDimensions()) - { - outData.Set(operationFunc(inData0.Get(), inData1.Get())); - return; - } - - unsigned int inData0Movement = 0; - unsigned int inData1Movement = 0; - unsigned int outDataMovement = 0; - - for (unsigned int i = 0; i < m_DimData[dimension].m_DimSize; i++) - { - Unroll(operationFunc, dimension + 1, inData0, inData1, outData); - - inData0 += m_DimData[dimension].m_Stride1; - inData1 += m_DimData[dimension].m_Stride2; - outData += m_DimData[dimension].m_StrideOut; - - inData0Movement += m_DimData[dimension].m_Stride1; - inData1Movement += m_DimData[dimension].m_Stride2; - outDataMovement += m_DimData[dimension].m_StrideOut; - } - - // move iterator back to the start - inData0 -= inData0Movement; - inData1 -= inData1Movement; - outData -= outDataMovement; - } - - template <typename Func, typename DecoderOp, typename EncoderOp> - void Unroll(Func operationFunc, - unsigned int dimension, - DecoderOp& inData, - EncoderOp& outData) - { - if (dimension >= GetNumDimensions()) - { - outData.Set(operationFunc(inData.Get())); - return; - } - - unsigned int inDataMovement = 0; - unsigned int outDataMovement = 0; - - for (unsigned int i = 0; i < m_DimData[dimension].m_DimSize; i++) - { - Unroll(operationFunc, dimension + 1, inData, outData); - - inData += m_DimData[dimension].m_Stride1; - outData += m_DimData[dimension].m_StrideOut; - - inDataMovement += m_DimData[dimension].m_Stride1; - outDataMovement += m_DimData[dimension].m_StrideOut; - } - - // move iterator back to the start - inData -= inDataMovement; - outData -= outDataMovement; - } - -private: - // Struct to hold the dimension data. - struct BroadcastDimensionData - { - unsigned int m_DimSize; - unsigned int m_StrideOut; - unsigned int m_Stride1; - unsigned int m_Stride2; - }; - - std::vector<BroadcastDimensionData> m_DimData; -}; - -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt deleted file mode 100644 index 6795204d59..0000000000 --- a/src/backends/reference/workloads/CMakeLists.txt +++ /dev/null @@ -1,175 +0,0 @@ -# -# Copyright © 2017 Arm Ltd. All rights reserved. -# SPDX-License-Identifier: MIT -# - -list(APPEND armnnRefBackendWorkloads_sources - Abs.hpp - ArgMinMax.cpp - ArgMinMax.hpp - Activation.cpp - Activation.hpp - ArgMinMax.cpp - ArgMinMax.hpp - BaseIterator.hpp - BatchNormImpl.cpp - BatchNormImpl.hpp - BatchToSpaceNd.cpp - BatchToSpaceNd.hpp - Broadcast.cpp - Broadcast.hpp - ConvImpl.cpp - ConvImpl.hpp - Debug.cpp - Debug.hpp - Decoders.hpp - DepthToSpace.cpp - DepthToSpace.hpp - DetectionPostProcess.cpp - DetectionPostProcess.hpp - Dequantize.cpp - Dequantize.hpp - ElementwiseFunction.cpp - ElementwiseFunction.hpp - Encoders.hpp - Exp.hpp - FullyConnected.cpp - FullyConnected.hpp - Gather.cpp - Gather.hpp - InstanceNorm.cpp - InstanceNorm.hpp - LogSoftmax.cpp - LogSoftmax.hpp - LstmUtils.hpp - LstmUtils.cpp - Maximum.hpp - Mean.cpp - Mean.hpp - Concatenate.hpp - Concatenate.cpp - Minimum.hpp - Pad.cpp - Pad.hpp - Pooling2d.cpp - Pooling2d.hpp - PreluImpl.cpp - PreluImpl.hpp - RefActivationWorkload.cpp - RefActivationWorkload.hpp - RefArgMinMaxWorkload.cpp - RefArgMinMaxWorkload.hpp - RefBatchNormalizationWorkload.cpp - RefBatchNormalizationWorkload.hpp - RefBatchToSpaceNdWorkload.cpp - RefBatchToSpaceNdWorkload.hpp - RefComparisonWorkload.cpp - RefComparisonWorkload.hpp - RefConcatWorkload.cpp - RefConcatWorkload.hpp - RefConstantWorkload.cpp - RefConstantWorkload.hpp - RefConvertFp16ToFp32Workload.cpp - RefConvertFp16ToFp32Workload.hpp - RefConvertFp32ToFp16Workload.cpp - RefConvertFp32ToFp16Workload.hpp - RefConvolution2dWorkload.cpp - RefConvolution2dWorkload.hpp - RefElementwiseWorkload.cpp - RefElementwiseWorkload.hpp - RefDebugWorkload.cpp - RefDebugWorkload.hpp - RefDepthToSpaceWorkload.cpp - RefDepthToSpaceWorkload.hpp - RefDepthwiseConvolution2dWorkload.cpp - RefDepthwiseConvolution2dWorkload.hpp - RefDequantizeWorkload.cpp - RefDequantizeWorkload.hpp - RefDetectionPostProcessWorkload.cpp - RefDetectionPostProcessWorkload.hpp - RefElementwiseUnaryWorkload.cpp - RefElementwiseUnaryWorkload.hpp - RefFakeQuantizationFloat32Workload.cpp - RefFakeQuantizationFloat32Workload.hpp - RefFloorWorkload.cpp - RefFloorWorkload.hpp - RefFullyConnectedWorkload.cpp - RefFullyConnectedWorkload.hpp - RefGatherWorkload.cpp - RefGatherWorkload.hpp - RefInstanceNormalizationWorkload.cpp - RefInstanceNormalizationWorkload.hpp - RefL2NormalizationWorkload.cpp - RefL2NormalizationWorkload.hpp - RefLogSoftmaxWorkload.cpp - RefLogSoftmaxWorkload.hpp - RefLstmWorkload.cpp - RefLstmWorkload.hpp - RefMeanWorkload.cpp - RefMeanWorkload.hpp - RefNormalizationWorkload.cpp - RefNormalizationWorkload.hpp - RefPadWorkload.cpp - RefPadWorkload.hpp - RefPermuteWorkload.cpp - RefPermuteWorkload.hpp - RefPooling2dWorkload.cpp - RefPooling2dWorkload.hpp - RefPreluWorkload.cpp - RefPreluWorkload.hpp - RefQuantizeWorkload.cpp - RefQuantizeWorkload.hpp - RefReshapeWorkload.cpp - RefReshapeWorkload.hpp - RefResizeBilinearWorkload.cpp - RefResizeBilinearWorkload.hpp - RefResizeWorkload.cpp - RefResizeWorkload.hpp - RefSliceWorkload.cpp - RefSliceWorkload.hpp - RefSoftmaxWorkload.cpp - RefSoftmaxWorkload.hpp - RefSpaceToBatchNdWorkload.cpp - RefSpaceToBatchNdWorkload.hpp - RefSpaceToDepthWorkload.cpp - RefSpaceToDepthWorkload.hpp - RefSplitterWorkload.cpp - RefSplitterWorkload.hpp - RefStackWorkload.cpp - RefStackWorkload.hpp - RefStridedSliceWorkload.cpp - RefStridedSliceWorkload.hpp - RefTransposeConvolution2dWorkload.cpp - RefTransposeConvolution2dWorkload.hpp - RefWorkloads.hpp - RefWorkloadUtils.hpp - Resize.cpp - Resize.hpp - Rsqrt.hpp - Slice.cpp - Slice.hpp - Softmax.cpp - Softmax.hpp - SpaceToBatchNd.hpp - SpaceToBatchNd.cpp - SpaceToDepth.hpp - SpaceToDepth.cpp - Splitter.hpp - Splitter.cpp - Sqrt.hpp - Stack.cpp - Stack.hpp - StridedSlice.hpp - StridedSlice.cpp - StringMapping.cpp - StringMapping.hpp - TensorBufferArrayView.hpp - TransposeConvolution2d.cpp - TransposeConvolution2d.hpp -) - -add_library(armnnRefBackendWorkloads OBJECT ${armnnRefBackendWorkloads_sources}) -target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn) -target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils) -target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/backends) -target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/profiling) diff --git a/src/backends/reference/workloads/Concatenate.cpp b/src/backends/reference/workloads/Concatenate.cpp deleted file mode 100644 index bb55424c0c..0000000000 --- a/src/backends/reference/workloads/Concatenate.cpp +++ /dev/null @@ -1,83 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Concatenate.hpp" -#include "RefWorkloadUtils.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -void Concatenate(const ConcatQueueDescriptor &data) -{ - const TensorInfo& outputInfo0 = GetTensorInfo(data.m_Outputs[0]); - - std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputInfo0, data.m_Outputs[0]->Map()); - Encoder<float>& encoder = *encoderPtr; - - for (unsigned int index = 0 ; index < outputInfo0.GetNumElements(); ++index) - { - unsigned int indices[MaxNumOfTensorDimensions] = { 0 }; - - unsigned int indexRemainder = index; - unsigned int dimensionStride = outputInfo0.GetNumElements(); - - for (unsigned int i = 0; i < outputInfo0.GetNumDimensions(); i++) - { - dimensionStride /= outputInfo0.GetShape()[i]; - indices[i] = indexRemainder / dimensionStride; // Use integer division to round down. - indexRemainder -= indices[i] * dimensionStride; - } - - for (unsigned int viewIdx = 0; viewIdx < data.m_ViewOrigins.size(); ++viewIdx) - { - ConcatQueueDescriptor::ViewOrigin const& view = data.m_ViewOrigins[viewIdx]; - - //Split view extents are defined by the size of (the corresponding) input tensor. - const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[viewIdx]); - BOOST_ASSERT(inputInfo.GetNumDimensions() == outputInfo0.GetNumDimensions()); - - // Check all dimensions to see if this element is inside the given input view. - bool insideView = true; - for (unsigned int i = 0; i < inputInfo.GetNumDimensions(); i++) - { - if (indices[i] < view.m_Origin[i]) - { - insideView = false; - } - if (indices[i] >= view.m_Origin[i] + inputInfo.GetShape()[i]) - { - insideView = false; - } - } - - if (insideView) - { - std::unique_ptr<Decoder<float>> decoderPtr = - MakeDecoder<float>(inputInfo, data.m_Inputs[viewIdx]->Map()); - Decoder<float>& decoder = *decoderPtr; - unsigned int inIndex = 0; - unsigned int dimensionStride = 1; - - for (unsigned int i = inputInfo.GetNumDimensions(); i-- > 0;) - { - inIndex += dimensionStride * (indices[i] - view.m_Origin[i]); - dimensionStride *= inputInfo.GetShape()[i]; - } - decoder += inIndex; - encoder.Set(decoder.Get()); - - //What should we do if input views overlap on the output tensor? - //We could error, take the average, or shm else... - //For now just stop after finding first view (input) that matches. - break; - } - } - ++encoder; - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/Concatenate.hpp b/src/backends/reference/workloads/Concatenate.hpp deleted file mode 100644 index ac82a87af3..0000000000 --- a/src/backends/reference/workloads/Concatenate.hpp +++ /dev/null @@ -1,14 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/WorkloadData.hpp> -#include <armnn/Tensor.hpp> - -namespace armnn -{ -void Concatenate(const ConcatQueueDescriptor &data); -} //namespace armnn diff --git a/src/backends/reference/workloads/ConvImpl.cpp b/src/backends/reference/workloads/ConvImpl.cpp deleted file mode 100644 index 0c13e3ba0d..0000000000 --- a/src/backends/reference/workloads/ConvImpl.cpp +++ /dev/null @@ -1,228 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "ConvImpl.hpp" - -#include <boost/assert.hpp> - -#include <cmath> -#include <limits> - -namespace armnn -{ - -QuantizedMultiplierSmallerThanOne::QuantizedMultiplierSmallerThanOne(float multiplier) -{ - BOOST_ASSERT(multiplier >= 0.0f && multiplier < 1.0f); - if (multiplier == 0.0f) - { - m_Multiplier = 0; - m_RightShift = 0; - } - else - { - const double q = std::frexp(multiplier, &m_RightShift); - m_RightShift = -m_RightShift; - int64_t qFixed = static_cast<int64_t>(std::round(q * (1ll << 31))); - BOOST_ASSERT(qFixed <= (1ll << 31)); - if (qFixed == (1ll << 31)) - { - qFixed /= 2; - --m_RightShift; - } - BOOST_ASSERT(m_RightShift >= 0); - BOOST_ASSERT(qFixed <= std::numeric_limits<int32_t>::max()); - m_Multiplier = static_cast<int32_t>(qFixed); - } -} - -int32_t QuantizedMultiplierSmallerThanOne::operator*(int32_t rhs) const -{ - int32_t x = SaturatingRoundingDoublingHighMul(rhs, m_Multiplier); - return RoundingDivideByPOT(x, m_RightShift); -} - -int32_t QuantizedMultiplierSmallerThanOne::SaturatingRoundingDoublingHighMul(int32_t a, int32_t b) -{ - // Check for overflow. - if (a == b && a == std::numeric_limits<int32_t>::min()) - { - return std::numeric_limits<int32_t>::max(); - } - int64_t a_64(a); - int64_t b_64(b); - int64_t ab_64 = a_64 * b_64; - int32_t nudge = ab_64 >= 0 ? (1 << 30) : (1 - (1 << 30)); - int32_t ab_x2_high32 = static_cast<std::int32_t>((ab_64 + nudge) / (1ll << 31)); - return ab_x2_high32; -} - -int32_t QuantizedMultiplierSmallerThanOne::RoundingDivideByPOT(int32_t x, int exponent) -{ - BOOST_ASSERT(exponent >= 0 && exponent <= 31); - int32_t mask = (1 << exponent) - 1; - int32_t remainder = x & mask; - int32_t threshold = (mask >> 1) + (x < 0 ? 1 : 0); - return (x >> exponent) + (remainder > threshold ? 1 : 0); -} - -void Convolve(const TensorShape& rInputShape, - Decoder<float>& rInputDecoder, - const TensorShape& rOutputShape, - Encoder<float>& rOutputEncoder, - const TensorShape& rFilterShape, - Decoder<float>& rFilterDecoder, - bool biasEnabled, - Decoder<float>* pBiasDecoder, - DataLayout dataLayout, - unsigned int paddingTop, - unsigned int paddingLeft, - unsigned int xStride, - unsigned int yStride, - unsigned int xDilation, - unsigned int yDilation, - bool depthwise) -{ - if (biasEnabled && !pBiasDecoder) - { - throw InvalidArgumentException("Bias is enabled but the bias data is invalid"); - } - const armnnUtils::DataLayoutIndexed dataLayoutIndexed(dataLayout); - - const unsigned int channelsIndex = dataLayoutIndexed.GetChannelsIndex(); - const unsigned int heightIndex = dataLayoutIndexed.GetHeightIndex(); - const unsigned int widthIndex = dataLayoutIndexed.GetWidthIndex(); - - unsigned int depthMultiplier = depthwise ? rFilterShape[0] : 1; - unsigned int inputChannels = depthwise ? rFilterShape[1] : rFilterShape[channelsIndex]; - unsigned int outputChannels = depthwise ? inputChannels * depthMultiplier : rFilterShape[0]; - - unsigned int batchSize = rOutputShape[0]; - unsigned int outputHeight = rOutputShape[heightIndex]; - unsigned int outputWidth = rOutputShape[widthIndex]; - unsigned int inputHeight = rInputShape[heightIndex]; - unsigned int inputWidth = rInputShape[widthIndex]; - - unsigned int filterHeight = depthwise ? rFilterShape[2] : rFilterShape[heightIndex]; - unsigned int filterWidth = depthwise ? rFilterShape[3] : rFilterShape[widthIndex]; - - for (unsigned int batchIdx = 0; batchIdx < batchSize; batchIdx++) - { - for (unsigned int cOutput = 0; cOutput < outputChannels; cOutput++) - { - for (unsigned int yOutput = 0; yOutput < outputHeight; yOutput++) - { - for (unsigned int xOutput = 0; xOutput < outputWidth; xOutput++) - { - // This loop goes over each output element. - float sum = 0.0f; - - // For depthwise, each output channel corresponds to exactly one input channel. - // For normal, must loop over each input channel. - for (unsigned int cInput = 0; cInput < (depthwise ? 1 : inputChannels); cInput++) - { - unsigned int depthwiseMultiplierIdx = 0; - if (depthwise) - { - cInput = cOutput / depthMultiplier; - depthwiseMultiplierIdx = cOutput % depthMultiplier; - } - - for (unsigned int yFilter = 0; yFilter < filterHeight; yFilter++) - { - for (unsigned int xFilter = 0; xFilter < filterWidth; xFilter++) - { - // This loop goes over each input element for each output element. - unsigned int filterIndex = 0; - - // Since dimensionality of kernel depends on depthwiseness, so does index. - if (depthwise) - { - filterIndex = depthwiseMultiplierIdx * filterWidth * filterHeight * inputChannels + - cInput * filterWidth * filterHeight + - yFilter * filterWidth + - xFilter; - } - else - { - // Keep this implementation, as using DataLayoutIndexed::GetIndex causes great - // performance regression. - if (dataLayout == DataLayout::NHWC) - { - filterIndex = cOutput * filterHeight * filterWidth * inputChannels + - yFilter * filterWidth * inputChannels + - xFilter * inputChannels + - cInput; - } - else - { - filterIndex = cOutput * filterWidth * filterHeight * inputChannels + - cInput * filterWidth * filterHeight + - yFilter * filterWidth + - xFilter; - } - } - - rFilterDecoder.SetIndex(filterIndex, cOutput); - float filterValue = rFilterDecoder.Get(); - - unsigned int yInput = yOutput * yStride + yFilter * yDilation; - unsigned int xInput = xOutput * xStride + xFilter * xDilation; - - float inputValue; - - // Check if we're in the padding. - if (yInput < paddingTop || yInput >= inputHeight + paddingTop || - xInput < paddingLeft || xInput >= inputWidth + paddingLeft ) - { - inputValue = 0.0f; - } - else - { - unsigned int inputIndex = 0; - - // Keep this implementation, as using DataLayoutIndexed::GetIndex causes great - // performance regression. - if (dataLayout == DataLayout::NHWC) - { - inputIndex = batchIdx * inputHeight * inputWidth * inputChannels + - (yInput - paddingTop) * inputWidth * inputChannels + - (xInput - paddingLeft) * inputChannels + - cInput; - } - else - { - inputIndex = batchIdx * inputWidth * inputHeight * inputChannels + - inputWidth * inputHeight * cInput + - inputWidth * (yInput - paddingTop) + - xInput - paddingLeft; - } - - rInputDecoder[inputIndex]; - inputValue = rInputDecoder.Get(); - } - - sum += filterValue * inputValue; - } - } - } - - if (biasEnabled) - { - (*pBiasDecoder).SetIndex(cOutput, cOutput); - sum += pBiasDecoder->Get(); - } - - unsigned int outIdx = dataLayoutIndexed.GetIndex(rOutputShape, batchIdx, cOutput, yOutput, xOutput); - - rOutputEncoder[outIdx]; - rOutputEncoder.Set(sum); - } - } - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/ConvImpl.hpp b/src/backends/reference/workloads/ConvImpl.hpp deleted file mode 100644 index 562fd3e296..0000000000 --- a/src/backends/reference/workloads/ConvImpl.hpp +++ /dev/null @@ -1,67 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "RefWorkloadUtils.hpp" -#include "TensorBufferArrayView.hpp" -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <armnn/Tensor.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <boost/assert.hpp> -#include <boost/numeric/conversion/cast.hpp> - -#include <cmath> -#include <limits> - -namespace armnn -{ - -/// Performs multiplication of an integer with a multiplier which is less than one, -/// using quantized integer arithmetic which is consistent with AndroidNN's CPU executor. -struct QuantizedMultiplierSmallerThanOne -{ -public: - /// Constructs a QuantizedMultiplierSmallerThanOne which will multiply by the given multiplier. - /// This stores the appropriate integer quantities (derived from the given multiplier) for later use. - /// The implementation of this function is adapted from Android NN's QuantizeMultiplierSmallerThanOne(). - QuantizedMultiplierSmallerThanOne(float multiplier); - - /// The implementation of this function is adapted from Android NN's MultiplyByQuantizedMultiplierSmallerThanOne(). - int32_t operator*(int32_t rhs) const; - -private: - /// The implementation of this function is adapted from gemmlowp's SaturatingRoundingDoublingHighMul(). - static int32_t SaturatingRoundingDoublingHighMul(int32_t a, int32_t b); - - /// The implementation of this function is adapted from gemmlowp's RoundingDivideByPOT(). - static int32_t RoundingDivideByPOT(int32_t x, int exponent); - - int32_t m_Multiplier; - int32_t m_RightShift; -}; - -void Convolve(const TensorShape& rInputShape, - Decoder<float>& rInputDecoder, - const TensorShape& rOutputShape, - Encoder<float>& rOutputEncoder, - const TensorShape& rFilterShape, - Decoder<float>& rFilterDecoder, - bool biasEnabled, - Decoder<float>* pBiasDecoder, - DataLayout dataLayout, - unsigned int paddingTop, - unsigned int paddingLeft, - unsigned int xStride, - unsigned int yStride, - unsigned int xDilation, - unsigned int yDilation, - bool depthwise = false); -} //namespace armnn diff --git a/src/backends/reference/workloads/Debug.cpp b/src/backends/reference/workloads/Debug.cpp deleted file mode 100644 index 49e9e02ffb..0000000000 --- a/src/backends/reference/workloads/Debug.cpp +++ /dev/null @@ -1,127 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Debug.hpp" - -#include <Half.hpp> - -#include <boost/numeric/conversion/cast.hpp> - -#include <algorithm> -#include <iostream> - -namespace armnn -{ - -template <typename T> -void Debug(const TensorInfo& inputInfo, - const T* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex) -{ - const unsigned int numDims = inputInfo.GetNumDimensions(); - const unsigned int numElements = inputInfo.GetNumElements(); - const TensorShape& inputShape = inputInfo.GetShape(); - - std::vector<unsigned int> strides(numDims, 0); - strides[numDims - 1] = inputShape[numDims - 1]; - - for (unsigned int i = 2; i <= numDims; i++) - { - strides[numDims - i] = strides[numDims - i + 1] * inputShape[numDims - i]; - } - - std::cout << "{ "; - std::cout << "\"layerGuid\": " << guid << ", "; - std::cout << "\"layerName\": \"" << layerName << "\", "; - std::cout << "\"outputSlot\": " << slotIndex << ", "; - std::cout << "\"shape\": "; - - std::cout << "["; - for (unsigned int i = 0; i < numDims; i++) - { - std::cout << inputShape[i]; - if (i != numDims - 1) - { - std::cout << ", "; - } - } - std::cout << "], "; - - std::cout << "\"min\": " - << boost::numeric_cast<float>(*std::min_element(inputData, inputData + numElements)) << ", "; - - std::cout << "\"max\": " - << boost::numeric_cast<float>(*std::max_element(inputData, inputData + numElements)) << ", "; - - std::cout << "\"data\": "; - - for (unsigned int i = 0; i < numElements; i++) - { - for (unsigned int j = 0; j < numDims; j++) - { - if (i % strides[j] == 0) - { - std::cout << "[" ; - } - } - - std::cout << boost::numeric_cast<float>(inputData[i]); - - for (unsigned int j = 0; j < numDims; j++) - { - if ((i+1) % strides[j] == 0) - { - std::cout << "]" ; - } - } - - if (i != numElements - 1) - { - std::cout << ", "; - } - } - - std::cout << " }" << std::endl; -} - -template void Debug<Half>(const TensorInfo& inputInfo, - const Half* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex); - -template void Debug<float>(const TensorInfo& inputInfo, - const float* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex); - -template void Debug<uint8_t>(const TensorInfo& inputInfo, - const uint8_t* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex); - -template void Debug<int8_t>(const TensorInfo& inputInfo, - const int8_t* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex); - -template void Debug<int16_t>(const TensorInfo& inputInfo, - const int16_t* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex); - -template void Debug<int32_t>(const TensorInfo& inputInfo, - const int32_t* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex); - -} // namespace armnn diff --git a/src/backends/reference/workloads/Debug.hpp b/src/backends/reference/workloads/Debug.hpp deleted file mode 100644 index 3f9920c543..0000000000 --- a/src/backends/reference/workloads/Debug.hpp +++ /dev/null @@ -1,19 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <armnn/Tensor.hpp> - -namespace armnn -{ - -template <typename T> -void Debug(const TensorInfo& inputInfo, - const T* inputData, - LayerGuid guid, - const std::string& layerName, - unsigned int slotIndex); - -} //namespace armnn diff --git a/src/backends/reference/workloads/Decoders.hpp b/src/backends/reference/workloads/Decoders.hpp deleted file mode 100644 index 6a8c756048..0000000000 --- a/src/backends/reference/workloads/Decoders.hpp +++ /dev/null @@ -1,144 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" - -#include <armnnUtils/FloatingPointConverter.hpp> -#include <armnnUtils/TensorUtils.hpp> - -#include <boost/assert.hpp> - -namespace armnn -{ - -namespace -{ - -inline std::unique_ptr<Decoder<float>> MakeSigned32PerAxisDecoder(const TensorInfo& info, const void* data) -{ - auto params = armnnUtils::GetPerAxisParams(info); - return std::make_unique<ScaledInt32PerAxisDecoder>( - static_cast<const int32_t*>(data), - params.second, - params.first); -} - -inline std::unique_ptr<Decoder<float>> MakeSigned32Decoder(const TensorInfo& info, const void* data) -{ - if(info.HasMultipleQuantizationScales()) - { - // NOTE: If we have multiple quantization scales, we create a ScaledInt32PerAxisDecoder. - // This will be used to decode per-axis quantized convolution biases. - return MakeSigned32PerAxisDecoder(info, data); - } - else - { - if (info.GetQuantizationDim().has_value()) - { - // NOTE: Even though we only have a single quantization scale, if the quantization - // dimension is set, the tensor has per-axis quantization and we need to create a - // ScaledInt32PerAxisDecoder - return MakeSigned32PerAxisDecoder(info, data); - } - - const float scale = info.GetQuantizationScale(); - if (scale == 0.f) - { - // NOTE:: If no quantization scale is set, we create an Int32Decoder, which simply - // casts the int value to float. This will be used for any INT32 data other than - // convolution biases. - return std::make_unique<Int32Decoder>(static_cast<const int32_t*>(data)); - } - - // NOTE: If we only have a single (non-zero) quantization scale and no quantization - // dimension is specified, we need to create a ScaledInt32Decoder. This will be used - // to decode per-tensor quantized convolution biases. - return std::make_unique<ScaledInt32Decoder>(static_cast<const int32_t*>(data), scale); - } -} - -} // anonymous namespace - -template<typename T> -inline std::unique_ptr<Decoder<T>> MakeDecoder(const TensorInfo& info, const void* data = nullptr); - -template<> -inline std::unique_ptr<Decoder<float>> MakeDecoder(const TensorInfo& info, const void* data) -{ - switch(info.GetDataType()) - { - ARMNN_NO_DEPRECATE_WARN_BEGIN - case armnn::DataType::QuantizedSymm8PerAxis: - { - std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info); - return std::make_unique<QSymm8PerAxisDecoder>( - static_cast<const int8_t*>(data), - params.second, - params.first); - } - ARMNN_NO_DEPRECATE_WARN_END - case DataType::QAsymmS8: - { - return std::make_unique<QASymmS8Decoder>( - static_cast<const int8_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - case DataType::QAsymmU8: - { - return std::make_unique<QASymm8Decoder>( - static_cast<const uint8_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - case DataType::QSymmS16: - { - return std::make_unique<QSymm16Decoder>( - static_cast<const int16_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - case DataType::Float16: - { - return std::make_unique<Float16Decoder>(static_cast<const Half*>(data)); - } - case DataType::Float32: - { - return std::make_unique<Float32Decoder>(static_cast<const float*>(data)); - } - case DataType::Signed32: - { - return MakeSigned32Decoder(info, data); - } - case DataType::QSymmS8: - { - if (info.HasPerAxisQuantization()) - { - std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info); - return std::make_unique<QSymm8PerAxisDecoder>( - static_cast<const int8_t*>(data), - params.second, - params.first); - } - else - { - return std::make_unique<QSymmS8Decoder>( - static_cast<const int8_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - } - default: - { - BOOST_ASSERT_MSG(false, "Unsupported Data Type!"); - break; - } - } - return nullptr; -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/DepthToSpace.cpp b/src/backends/reference/workloads/DepthToSpace.cpp deleted file mode 100644 index 91ca160ae2..0000000000 --- a/src/backends/reference/workloads/DepthToSpace.cpp +++ /dev/null @@ -1,79 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "DepthToSpace.hpp" - -#include <armnnUtils/DataLayoutIndexed.hpp> -#include <armnnUtils/Permute.hpp> - -#include <boost/assert.hpp> - -using namespace armnnUtils; - -namespace armnn -{ - -void DepthToSpace(const TensorInfo& inputInfo, - const DepthToSpaceDescriptor& descriptor, - const void* inputData, - void* outputData, - unsigned int dataTypeSize) -{ - const unsigned int blockSize = descriptor.m_BlockSize; - BOOST_ASSERT(blockSize != 0u); - - const TensorShape& inputShape = inputInfo.GetShape(); - const unsigned int batches = inputShape[0]; - - armnnUtils::DataLayoutIndexed dataLayoutIndexed(descriptor.m_DataLayout); - const unsigned int inDepth = inputShape[dataLayoutIndexed.GetChannelsIndex()]; - const unsigned int inHeight = inputShape[dataLayoutIndexed.GetHeightIndex()]; - const unsigned int inWidth = inputShape[dataLayoutIndexed.GetWidthIndex()]; - - const unsigned int outDepth = inDepth / (blockSize * blockSize); - - // The 4D input data can be interpreted as 6D (implicitly reshaped) as follows: - // - // [batch, block size, block size, inDepth, inHeight, inWidth] for NCHW and - // [batch, inHeight, inWidth, blockSize, blockSize, outDepth] for NHWC. - // - // DepthToSpace can then be implemented as a permutation in 6D resulting in - // the following shapes: - // - // [batch, outDepth, inHeight, blockSize, inWidth, blockSize] for NCHW and - // [batch, inHeight, blockSize, inWidth, blockSize, outDepth] for NHWC. - // - // NOTE: - // Since 6D tensors are not currently supported, in practice we need to handle each - // batch separately and execute 5D permutations - - TensorShape permDestShape; - PermutationVector permVector{}; - if (descriptor.m_DataLayout == DataLayout::NCHW) - { - permDestShape = TensorShape({ outDepth, inHeight, blockSize, inWidth, blockSize }); - permVector = { 2, 4, 0, 1, 3 }; - } - else - { - permDestShape = TensorShape({ inHeight, blockSize, inWidth, blockSize, outDepth }); - permVector = { 0, 2, 1, 3, 4 }; - } - - const unsigned int numElementsPerBatch = inputShape.GetNumElements() / batches; - - for (unsigned int batchIndex = 0u; batchIndex < batches; ++batchIndex) - { - const uintptr_t batchDataOffset = batchIndex * (numElementsPerBatch * dataTypeSize); - - armnnUtils::Permute(permDestShape, - permVector, - static_cast<const void*>(reinterpret_cast<const uint8_t*>(inputData) + batchDataOffset), - static_cast<void*>(reinterpret_cast<uint8_t*>(outputData) + batchDataOffset), - dataTypeSize); - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/DepthToSpace.hpp b/src/backends/reference/workloads/DepthToSpace.hpp deleted file mode 100644 index a1805c02be..0000000000 --- a/src/backends/reference/workloads/DepthToSpace.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Descriptors.hpp> -#include <armnn/Tensor.hpp> - -namespace armnn -{ - -void DepthToSpace(const TensorInfo& inputInfo, - const DepthToSpaceDescriptor& descriptor, - const void* inputData, - void* outputData, - unsigned int dataTypeSize); - -} // namespace armnn diff --git a/src/backends/reference/workloads/Dequantize.cpp b/src/backends/reference/workloads/Dequantize.cpp deleted file mode 100644 index 4025e8d7fa..0000000000 --- a/src/backends/reference/workloads/Dequantize.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Dequantize.hpp" - -#include <boost/core/ignore_unused.hpp> -namespace armnn -{ - -void Dequantize(Decoder<float>& inputDecoder, - Encoder<float>& outputEncoder, - const TensorInfo& inputInfo, - const TensorInfo& outputInfo) -{ - boost::ignore_unused(outputInfo); - BOOST_ASSERT(inputInfo.GetNumElements() == outputInfo.GetNumElements()); - for (unsigned int i = 0; i < inputInfo.GetNumElements(); i++) - { - // inputDecoder.Get() dequantizes the data element from whatever - // type is given by inputInfo to fp32 (If MakeDecoder supports that dequantization) - // outputEncoder.Set() transforms the data element to whatever type is - // given by outputInfo (if MakeEncoder supports that transformation) - outputEncoder.Set(inputDecoder.Get()); - ++outputEncoder; - ++inputDecoder; - } -} - -} // armnn namespace
\ No newline at end of file diff --git a/src/backends/reference/workloads/Dequantize.hpp b/src/backends/reference/workloads/Dequantize.hpp deleted file mode 100644 index c01b454833..0000000000 --- a/src/backends/reference/workloads/Dequantize.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Tensor.hpp> -#include "Encoders.hpp" -#include "Decoders.hpp" - -namespace armnn -{ - -void Dequantize(Decoder<float>& inputDecoder, - Encoder<float>& outputEncoder, - const TensorInfo& inputInfo, - const TensorInfo& outputInfo); - -} //namespace armnn diff --git a/src/backends/reference/workloads/DetectionPostProcess.cpp b/src/backends/reference/workloads/DetectionPostProcess.cpp deleted file mode 100644 index 96e57803a1..0000000000 --- a/src/backends/reference/workloads/DetectionPostProcess.cpp +++ /dev/null @@ -1,323 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "DetectionPostProcess.hpp" - - -#include <boost/assert.hpp> -#include <boost/numeric/conversion/cast.hpp> - -#include <algorithm> -#include <numeric> - -namespace armnn -{ - -std::vector<unsigned int> GenerateRangeK(unsigned int k) -{ - std::vector<unsigned int> range(k); - std::iota(range.begin(), range.end(), 0); - return range; -} - -void TopKSort(unsigned int k, unsigned int* indices, const float* values, unsigned int numElement) -{ - std::partial_sort(indices, indices + k, indices + numElement, - [&values](unsigned int i, unsigned int j) { return values[i] > values[j]; }); -} - -float IntersectionOverUnion(const float* boxI, const float* boxJ) -{ - // Box-corner format: ymin, xmin, ymax, xmax. - const int yMin = 0; - const int xMin = 1; - const int yMax = 2; - const int xMax = 3; - float areaI = (boxI[yMax] - boxI[yMin]) * (boxI[xMax] - boxI[xMin]); - float areaJ = (boxJ[yMax] - boxJ[yMin]) * (boxJ[xMax] - boxJ[xMin]); - float yMinIntersection = std::max(boxI[yMin], boxJ[yMin]); - float xMinIntersection = std::max(boxI[xMin], boxJ[xMin]); - float yMaxIntersection = std::min(boxI[yMax], boxJ[yMax]); - float xMaxIntersection = std::min(boxI[xMax], boxJ[xMax]); - float areaIntersection = std::max(yMaxIntersection - yMinIntersection, 0.0f) * - std::max(xMaxIntersection - xMinIntersection, 0.0f); - float areaUnion = areaI + areaJ - areaIntersection; - return areaIntersection / areaUnion; -} - -std::vector<unsigned int> NonMaxSuppression(unsigned int numBoxes, - const std::vector<float>& boxCorners, - const std::vector<float>& scores, - float nmsScoreThreshold, - unsigned int maxDetection, - float nmsIouThreshold) -{ - // Select boxes that have scores above a given threshold. - std::vector<float> scoresAboveThreshold; - std::vector<unsigned int> indicesAboveThreshold; - for (unsigned int i = 0; i < numBoxes; ++i) - { - if (scores[i] >= nmsScoreThreshold) - { - scoresAboveThreshold.push_back(scores[i]); - indicesAboveThreshold.push_back(i); - } - } - - // Sort the indices based on scores. - unsigned int numAboveThreshold = boost::numeric_cast<unsigned int>(scoresAboveThreshold.size()); - std::vector<unsigned int> sortedIndices = GenerateRangeK(numAboveThreshold); - TopKSort(numAboveThreshold, sortedIndices.data(), scoresAboveThreshold.data(), numAboveThreshold); - - // Number of output cannot be more than max detections specified in the option. - unsigned int numOutput = std::min(maxDetection, numAboveThreshold); - std::vector<unsigned int> outputIndices; - std::vector<bool> visited(numAboveThreshold, false); - - // Prune out the boxes with high intersection over union by keeping the box with higher score. - for (unsigned int i = 0; i < numAboveThreshold; ++i) - { - if (outputIndices.size() >= numOutput) - { - break; - } - if (!visited[sortedIndices[i]]) - { - outputIndices.push_back(indicesAboveThreshold[sortedIndices[i]]); - } - for (unsigned int j = i + 1; j < numAboveThreshold; ++j) - { - unsigned int iIndex = indicesAboveThreshold[sortedIndices[i]] * 4; - unsigned int jIndex = indicesAboveThreshold[sortedIndices[j]] * 4; - if (IntersectionOverUnion(&boxCorners[iIndex], &boxCorners[jIndex]) > nmsIouThreshold) - { - visited[sortedIndices[j]] = true; - } - } - } - return outputIndices; -} - -void AllocateOutputData(unsigned int numOutput, - unsigned int numSelected, - const std::vector<float>& boxCorners, - const std::vector<unsigned int>& outputIndices, - const std::vector<unsigned int>& selectedBoxes, - const std::vector<unsigned int>& selectedClasses, - const std::vector<float>& selectedScores, - float* detectionBoxes, - float* detectionScores, - float* detectionClasses, - float* numDetections) -{ - for (unsigned int i = 0; i < numOutput; ++i) - { - unsigned int boxIndex = i * 4; - if (i < numSelected) - { - unsigned int boxCornorIndex = selectedBoxes[outputIndices[i]] * 4; - detectionScores[i] = selectedScores[outputIndices[i]]; - detectionClasses[i] = boost::numeric_cast<float>(selectedClasses[outputIndices[i]]); - detectionBoxes[boxIndex] = boxCorners[boxCornorIndex]; - detectionBoxes[boxIndex + 1] = boxCorners[boxCornorIndex + 1]; - detectionBoxes[boxIndex + 2] = boxCorners[boxCornorIndex + 2]; - detectionBoxes[boxIndex + 3] = boxCorners[boxCornorIndex + 3]; - } - else - { - detectionScores[i] = 0.0f; - detectionClasses[i] = 0.0f; - detectionBoxes[boxIndex] = 0.0f; - detectionBoxes[boxIndex + 1] = 0.0f; - detectionBoxes[boxIndex + 2] = 0.0f; - detectionBoxes[boxIndex + 3] = 0.0f; - } - } - numDetections[0] = boost::numeric_cast<float>(numSelected); -} - -void DetectionPostProcess(const TensorInfo& boxEncodingsInfo, - const TensorInfo& scoresInfo, - const TensorInfo& anchorsInfo, - const TensorInfo& detectionBoxesInfo, - const TensorInfo& detectionClassesInfo, - const TensorInfo& detectionScoresInfo, - const TensorInfo& numDetectionsInfo, - const DetectionPostProcessDescriptor& desc, - Decoder<float>& boxEncodings, - Decoder<float>& scores, - Decoder<float>& anchors, - float* detectionBoxes, - float* detectionClasses, - float* detectionScores, - float* numDetections) -{ - boost::ignore_unused(anchorsInfo, detectionClassesInfo, detectionScoresInfo, numDetectionsInfo); - - // Transform center-size format which is (ycenter, xcenter, height, width) to box-corner format, - // which represents the lower left corner and the upper right corner (ymin, xmin, ymax, xmax) - std::vector<float> boxCorners(boxEncodingsInfo.GetNumElements()); - - const unsigned int numBoxes = boxEncodingsInfo.GetShape()[1]; - const unsigned int numScores = scoresInfo.GetNumElements(); - - for (unsigned int i = 0; i < numBoxes; ++i) - { - // Y - float boxEncodingY = boxEncodings.Get(); - float anchorY = anchors.Get(); - - ++boxEncodings; - ++anchors; - - // X - float boxEncodingX = boxEncodings.Get(); - float anchorX = anchors.Get(); - - ++boxEncodings; - ++anchors; - - // H - float boxEncodingH = boxEncodings.Get(); - float anchorH = anchors.Get(); - - ++boxEncodings; - ++anchors; - - // W - float boxEncodingW = boxEncodings.Get(); - float anchorW = anchors.Get(); - - ++boxEncodings; - ++anchors; - - float yCentre = boxEncodingY / desc.m_ScaleY * anchorH + anchorY; - float xCentre = boxEncodingX / desc.m_ScaleX * anchorW + anchorX; - - float halfH = 0.5f * expf(boxEncodingH / desc.m_ScaleH) * anchorH; - float halfW = 0.5f * expf(boxEncodingW / desc.m_ScaleW) * anchorW; - - unsigned int indexY = i * 4; - unsigned int indexX = indexY + 1; - unsigned int indexH = indexX + 1; - unsigned int indexW = indexH + 1; - - // ymin - boxCorners[indexY] = yCentre - halfH; - // xmin - boxCorners[indexX] = xCentre - halfW; - // ymax - boxCorners[indexH] = yCentre + halfH; - // xmax - boxCorners[indexW] = xCentre + halfW; - - BOOST_ASSERT(boxCorners[indexY] < boxCorners[indexH]); - BOOST_ASSERT(boxCorners[indexX] < boxCorners[indexW]); - } - - unsigned int numClassesWithBg = desc.m_NumClasses + 1; - - // Decode scores - std::vector<float> decodedScores; - decodedScores.reserve(numScores); - - for (unsigned int i = 0u; i < numScores; ++i) - { - decodedScores.emplace_back(scores.Get()); - ++scores; - } - - // Perform Non Max Suppression. - if (desc.m_UseRegularNms) - { - // Perform Regular NMS. - // For each class, perform NMS and select max detection numbers of the highest score across all classes. - std::vector<float> classScores(numBoxes); - - std::vector<unsigned int> selectedBoxesAfterNms; - selectedBoxesAfterNms.reserve(numBoxes); - - std::vector<float> selectedScoresAfterNms; - selectedBoxesAfterNms.reserve(numScores); - - std::vector<unsigned int> selectedClasses; - - for (unsigned int c = 0; c < desc.m_NumClasses; ++c) - { - // For each boxes, get scores of the boxes for the class c. - for (unsigned int i = 0; i < numBoxes; ++i) - { - classScores[i] = decodedScores[i * numClassesWithBg + c + 1]; - } - std::vector<unsigned int> selectedIndices = NonMaxSuppression(numBoxes, - boxCorners, - classScores, - desc.m_NmsScoreThreshold, - desc.m_DetectionsPerClass, - desc.m_NmsIouThreshold); - - for (unsigned int i = 0; i < selectedIndices.size(); ++i) - { - selectedBoxesAfterNms.push_back(selectedIndices[i]); - selectedScoresAfterNms.push_back(classScores[selectedIndices[i]]); - selectedClasses.push_back(c); - } - } - - // Select max detection numbers of the highest score across all classes - unsigned int numSelected = boost::numeric_cast<unsigned int>(selectedBoxesAfterNms.size()); - unsigned int numOutput = std::min(desc.m_MaxDetections, numSelected); - - // Sort the max scores among the selected indices. - std::vector<unsigned int> outputIndices = GenerateRangeK(numSelected); - TopKSort(numOutput, outputIndices.data(), selectedScoresAfterNms.data(), numSelected); - - AllocateOutputData(detectionBoxesInfo.GetShape()[1], numOutput, boxCorners, outputIndices, - selectedBoxesAfterNms, selectedClasses, selectedScoresAfterNms, - detectionBoxes, detectionScores, detectionClasses, numDetections); - } - else - { - // Perform Fast NMS. - // Select max scores of boxes and perform NMS on max scores, - // select max detection numbers of the highest score - unsigned int numClassesPerBox = std::min(desc.m_MaxClassesPerDetection, desc.m_NumClasses); - std::vector<float> maxScores; - std::vector<unsigned int>boxIndices; - std::vector<unsigned int>maxScoreClasses; - - for (unsigned int box = 0; box < numBoxes; ++box) - { - unsigned int scoreIndex = box * numClassesWithBg + 1; - - // Get the max scores of the box. - std::vector<unsigned int> maxScoreIndices = GenerateRangeK(desc.m_NumClasses); - TopKSort(numClassesPerBox, maxScoreIndices.data(), - decodedScores.data() + scoreIndex, desc.m_NumClasses); - - for (unsigned int i = 0; i < numClassesPerBox; ++i) - { - maxScores.push_back(decodedScores[scoreIndex + maxScoreIndices[i]]); - maxScoreClasses.push_back(maxScoreIndices[i]); - boxIndices.push_back(box); - } - } - - // Perform NMS on max scores - std::vector<unsigned int> selectedIndices = NonMaxSuppression(numBoxes, boxCorners, maxScores, - desc.m_NmsScoreThreshold, - desc.m_MaxDetections, - desc.m_NmsIouThreshold); - - unsigned int numSelected = boost::numeric_cast<unsigned int>(selectedIndices.size()); - unsigned int numOutput = std::min(desc.m_MaxDetections, numSelected); - - AllocateOutputData(detectionBoxesInfo.GetShape()[1], numOutput, boxCorners, selectedIndices, - boxIndices, maxScoreClasses, maxScores, - detectionBoxes, detectionScores, detectionClasses, numDetections); - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/DetectionPostProcess.hpp b/src/backends/reference/workloads/DetectionPostProcess.hpp deleted file mode 100644 index 8700a53317..0000000000 --- a/src/backends/reference/workloads/DetectionPostProcess.hpp +++ /dev/null @@ -1,47 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include "armnn/Tensor.hpp" -#include "armnn/Descriptors.hpp" - -#include "Decoders.hpp" - -#include <vector> - -namespace armnn -{ - -void DetectionPostProcess(const TensorInfo& boxEncodingsInfo, - const TensorInfo& scoresInfo, - const TensorInfo& anchorsInfo, - const TensorInfo& detectionBoxesInfo, - const TensorInfo& detectionClassesInfo, - const TensorInfo& detectionScoresInfo, - const TensorInfo& numDetectionsInfo, - const DetectionPostProcessDescriptor& desc, - Decoder<float>& boxEncodings, - Decoder<float>& scores, - Decoder<float>& anchors, - float* detectionBoxes, - float* detectionClasses, - float* detectionScores, - float* numDetections); - -void TopKSort(unsigned int k, - unsigned int* indices, - const float* values, - unsigned int numElement); - -float IntersectionOverUnion(const float* boxI, const float* boxJ); - -std::vector<unsigned int> NonMaxSuppression(unsigned int numBoxes, - const std::vector<float>& boxCorners, - const std::vector<float>& scores, - float nmsScoreThreshold, - unsigned int maxDetection, - float nmsIouThreshold); - -} // namespace armnn diff --git a/src/backends/reference/workloads/ElementwiseFunction.cpp b/src/backends/reference/workloads/ElementwiseFunction.cpp deleted file mode 100644 index 5687cf5861..0000000000 --- a/src/backends/reference/workloads/ElementwiseFunction.cpp +++ /dev/null @@ -1,62 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "ElementwiseFunction.hpp" -#include "Broadcast.hpp" -#include <functional> -#include "Minimum.hpp" -#include "Maximum.hpp" -#include "Abs.hpp" -#include "Exp.hpp" -#include "Rsqrt.hpp" -#include "Sqrt.hpp" - - -namespace armnn -{ - -template <typename Functor> -ElementwiseBinaryFunction<Functor>::ElementwiseBinaryFunction(const TensorShape& inShape0, - const TensorShape& inShape1, - const TensorShape& outShape, - Decoder<InType>& inData0, - Decoder<InType>& inData1, - Encoder<OutType>& outData) -{ - BroadcastLoop(inShape0, inShape1, outShape).Unroll(Functor(), 0, inData0, inData1, outData); -} - -template <typename Functor> -ElementwiseUnaryFunction<Functor>::ElementwiseUnaryFunction(const TensorShape& inShape, - const TensorShape& outShape, - Decoder<InType>& inData, - Encoder<OutType>& outData) -{ - BroadcastLoop(inShape, outShape).Unroll(Functor(), 0, inData, outData); -} - -} //namespace armnn - -template struct armnn::ElementwiseBinaryFunction<std::plus<float>>; -template struct armnn::ElementwiseBinaryFunction<std::minus<float>>; -template struct armnn::ElementwiseBinaryFunction<std::multiplies<float>>; -template struct armnn::ElementwiseBinaryFunction<std::divides<float>>; -template struct armnn::ElementwiseBinaryFunction<armnn::maximum<float>>; -template struct armnn::ElementwiseBinaryFunction<armnn::minimum<float>>; - -// Comparison -template struct armnn::ElementwiseBinaryFunction<std::equal_to<float>>; -template struct armnn::ElementwiseBinaryFunction<std::greater<float>>; -template struct armnn::ElementwiseBinaryFunction<std::greater_equal<float>>; -template struct armnn::ElementwiseBinaryFunction<std::less<float>>; -template struct armnn::ElementwiseBinaryFunction<std::less_equal<float>>; -template struct armnn::ElementwiseBinaryFunction<std::not_equal_to<float>>; - -// Unary -template struct armnn::ElementwiseUnaryFunction<armnn::abs<float>>; -template struct armnn::ElementwiseUnaryFunction<armnn::exp<float>>; -template struct armnn::ElementwiseUnaryFunction<std::negate<float>>; -template struct armnn::ElementwiseUnaryFunction<armnn::rsqrt<float>>; -template struct armnn::ElementwiseUnaryFunction<armnn::sqrt<float>>; diff --git a/src/backends/reference/workloads/ElementwiseFunction.hpp b/src/backends/reference/workloads/ElementwiseFunction.hpp deleted file mode 100644 index 8259ba5ac7..0000000000 --- a/src/backends/reference/workloads/ElementwiseFunction.hpp +++ /dev/null @@ -1,40 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" -#include <armnn/Tensor.hpp> - -namespace armnn -{ - -template <typename Functor> -struct ElementwiseBinaryFunction -{ - using OutType = typename Functor::result_type; - using InType = typename Functor::first_argument_type; - - ElementwiseBinaryFunction(const TensorShape& inShape0, - const TensorShape& inShape1, - const TensorShape& outShape, - Decoder<InType>& inData0, - Decoder<InType>& inData1, - Encoder<OutType>& outData); -}; - -template <typename Functor> -struct ElementwiseUnaryFunction -{ - using OutType = typename Functor::result_type; - using InType = typename Functor::argument_type; - - ElementwiseUnaryFunction(const TensorShape& inShape, - const TensorShape& outShape, - Decoder<InType>& inData, - Encoder<OutType>& outData); -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/Encoders.hpp b/src/backends/reference/workloads/Encoders.hpp deleted file mode 100644 index f52297602f..0000000000 --- a/src/backends/reference/workloads/Encoders.hpp +++ /dev/null @@ -1,113 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" - -#include <armnnUtils/TensorUtils.hpp> - -#include <boost/assert.hpp> - -namespace armnn -{ - -template<typename T> -inline std::unique_ptr<Encoder<T>> MakeEncoder(const TensorInfo& info, void* data = nullptr); - -template<> -inline std::unique_ptr<Encoder<float>> MakeEncoder(const TensorInfo& info, void* data) -{ - switch(info.GetDataType()) - { - ARMNN_NO_DEPRECATE_WARN_BEGIN - case armnn::DataType::QuantizedSymm8PerAxis: - { - std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info); - return std::make_unique<QSymm8PerAxisEncoder>( - static_cast<int8_t*>(data), - params.second, - params.first); - } - ARMNN_NO_DEPRECATE_WARN_END - case armnn::DataType::QAsymmS8: - { - return std::make_unique<QASymmS8Encoder>( - static_cast<int8_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - case armnn::DataType::QAsymmU8: - { - return std::make_unique<QASymm8Encoder>( - static_cast<uint8_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - case DataType::QSymmS8: - { - if (info.HasPerAxisQuantization()) - { - std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info); - return std::make_unique<QSymm8PerAxisEncoder>( - static_cast<int8_t*>(data), - params.second, - params.first); - } - else - { - return std::make_unique<QSymmS8Encoder>( - static_cast<int8_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - } - case armnn::DataType::QSymmS16: - { - return std::make_unique<QSymm16Encoder>( - static_cast<int16_t*>(data), - info.GetQuantizationScale(), - info.GetQuantizationOffset()); - } - case armnn::DataType::Signed32: - { - return std::make_unique<Int32Encoder>(static_cast<int32_t*>(data)); - } - case armnn::DataType::Float16: - { - return std::make_unique<Float16Encoder>(static_cast<Half*>(data)); - } - case armnn::DataType::Float32: - { - return std::make_unique<Float32Encoder>(static_cast<float*>(data)); - } - default: - { - BOOST_ASSERT_MSG(false, "Unsupported target Data Type!"); - break; - } - } - return nullptr; -} - -template<> -inline std::unique_ptr<Encoder<bool>> MakeEncoder(const TensorInfo& info, void* data) -{ - switch(info.GetDataType()) - { - case armnn::DataType::Boolean: - { - return std::make_unique<BooleanEncoder>(static_cast<uint8_t*>(data)); - } - default: - { - BOOST_ASSERT_MSG(false, "Cannot encode from boolean. Not supported target Data Type!"); - break; - } - } - return nullptr; -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/Exp.hpp b/src/backends/reference/workloads/Exp.hpp deleted file mode 100644 index 1a046728ba..0000000000 --- a/src/backends/reference/workloads/Exp.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <iostream> - -namespace armnn -{ - template<typename T> -struct exp : public std::unary_function<T, T> - { - T - operator () (const T& inputData) const - { - return std::exp(inputData); - } - }; - -} //namespace armnn diff --git a/src/backends/reference/workloads/FullyConnected.cpp b/src/backends/reference/workloads/FullyConnected.cpp deleted file mode 100644 index 02d9b060ef..0000000000 --- a/src/backends/reference/workloads/FullyConnected.cpp +++ /dev/null @@ -1,64 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "FullyConnected.hpp" - -#include "RefWorkloadUtils.hpp" - -#include <boost/assert.hpp> - -namespace armnn -{ - -void FullyConnected(const TensorShape& rInputShape, - Decoder<float>& rInputDecoder, - const TensorShape& rOutputShape, - Encoder<float>& rOutputEncoder, - Decoder<float>& rWeightDecoder, - Decoder<float>& rBiasDecoder, - const bool biasEnabled, - const unsigned int K, - const bool transposeWeights) -{ - // Perform FullyConnected implementation - unsigned int outputSize = rOutputShape[1]; - - for (unsigned int n = 0; n < rInputShape[0]; n++) - { - for (unsigned int channelOutput = 0; channelOutput < outputSize; channelOutput++) - { - float outval = 0.f; - - for (unsigned int channelInput = 0; channelInput < K; channelInput++) - { - float weight; - if (transposeWeights) - { - rWeightDecoder[channelOutput * K + channelInput]; - weight = rWeightDecoder.Get(); - } - else - { - rWeightDecoder[channelInput * outputSize + channelOutput]; - weight = rWeightDecoder.Get(); - } - - rInputDecoder[n * K + channelInput]; - outval += weight * rInputDecoder.Get(); - } - - if (biasEnabled) - { - rBiasDecoder[channelOutput]; - outval += rBiasDecoder.Get(); - } - - rOutputEncoder[n * outputSize + channelOutput]; - rOutputEncoder.Set(outval); - } - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/FullyConnected.hpp b/src/backends/reference/workloads/FullyConnected.hpp deleted file mode 100644 index 78fa055086..0000000000 --- a/src/backends/reference/workloads/FullyConnected.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" -#include <armnn/Tensor.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -/// Performs a matrix multiplication and optionally adds a bias. -void FullyConnected(const TensorShape& rInputShape, - Decoder<float>& rInputDecoder, - const TensorShape& rOutputShape, - Encoder<float>& rOutputEncoder, - Decoder<float>& rWeightDecoder, - Decoder<float>& rBiasDecoder, - bool biasEnabled, - unsigned int K, - bool transposeWeights); - -} //namespace armnn diff --git a/src/backends/reference/workloads/Gather.cpp b/src/backends/reference/workloads/Gather.cpp deleted file mode 100644 index 5416855f48..0000000000 --- a/src/backends/reference/workloads/Gather.cpp +++ /dev/null @@ -1,57 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Gather.hpp" - -#include "RefWorkloadUtils.hpp" - -#include <backendsCommon/WorkloadData.hpp> - -#include <boost/core/ignore_unused.hpp> -#include <boost/numeric/conversion/cast.hpp> - -namespace armnn -{ - -void Gather(const TensorInfo& paramsInfo, - const TensorInfo& indicesInfo, - const TensorInfo& outputInfo, - Decoder<float>& params, - const int32_t* indices, - Encoder<float>& output) -{ - boost::ignore_unused(outputInfo); - const TensorShape& paramsShape = paramsInfo.GetShape(); - - unsigned int paramsProduct = 1; - for (unsigned int i = 1; i < paramsInfo.GetNumDimensions(); ++i) - { - paramsProduct = paramsProduct * paramsShape[i]; - } - - unsigned int outIndex = 0; - for (unsigned int i = 0; i < indicesInfo.GetNumElements(); ++i) - { - unsigned int indx = boost::numeric_cast<unsigned int>(indices[i]); - - BOOST_ASSERT(indices[i] >= 0 && indx < paramsShape[0]); - - unsigned int startOffset = indx * paramsProduct; - unsigned int endOffset = startOffset + paramsProduct; - - for (unsigned int j = startOffset; j < endOffset; ++j) - { - params[j]; - float outputValue = params.Get(); - output[outIndex]; - output.Set(outputValue); - ++outIndex; - } - } - - BOOST_ASSERT(outIndex == outputInfo.GetNumElements()); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/Gather.hpp b/src/backends/reference/workloads/Gather.hpp deleted file mode 100644 index 16c983eec4..0000000000 --- a/src/backends/reference/workloads/Gather.hpp +++ /dev/null @@ -1,24 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "armnn/Tensor.hpp" - -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -void Gather(const TensorInfo& paramsInfo, - const TensorInfo& indicesInfo, - const TensorInfo& outputInfo, - Decoder<float>& params, - const int32_t* indices, - Encoder<float>& output); - -} //namespace armnn diff --git a/src/backends/reference/workloads/InstanceNorm.cpp b/src/backends/reference/workloads/InstanceNorm.cpp deleted file mode 100644 index 08c555f0e8..0000000000 --- a/src/backends/reference/workloads/InstanceNorm.cpp +++ /dev/null @@ -1,86 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "InstanceNorm.hpp" -#include "RefWorkloadUtils.hpp" - -#include <armnn/Tensor.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <cmath> - -namespace armnn -{ - -void InstanceNorm(const InstanceNormalizationQueueDescriptor& data, - Decoder<float>& inputDecoder, - Encoder<float>& outputEncoder) -{ - const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]); - const TensorShape inputShape = inputInfo.GetShape(); - - armnnUtils::DataLayoutIndexed dataLayout(data.m_Parameters.m_DataLayout); - - unsigned int inputBatches = inputShape[0]; - unsigned int inputHeight = inputShape[dataLayout.GetHeightIndex()]; - unsigned int inputWidth = inputShape[dataLayout.GetWidthIndex()]; - unsigned int inputChannels = inputShape[dataLayout.GetChannelsIndex()]; - - float beta = data.m_Parameters.m_Beta; - float eps = data.m_Parameters.m_Eps; - float gamma = data.m_Parameters.m_Gamma; - - for (unsigned int n = 0; n < inputBatches; ++n) - { - for (unsigned int c = 0; c < inputChannels; ++c) - { - float mean = 0, var = 0; - - //Calculate Mean - for (unsigned int h = 0; h < inputHeight; h++) - { - for (unsigned int w = 0; w < inputWidth; w++) - { - unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w); - - inputDecoder[index]; - float value = inputDecoder.Get(); - mean += value; - } - } - mean /= static_cast<float>(inputHeight * inputWidth); - - //Calculate Variance - for (unsigned int h = 0; h < inputHeight; h++) - { - for (unsigned int w = 0; w < inputWidth; w++) - { - unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w); - - inputDecoder[index]; - float value = inputDecoder.Get(); - var += (value - mean) * (value - mean); - } - } - var /= static_cast<float>(inputHeight * inputWidth); - - // Apply Instance Normalisation - for (unsigned int h = 0; h < inputHeight; ++h) - { - for (unsigned int w = 0; w < inputWidth; ++w) - { - unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w); - inputDecoder[index]; - outputEncoder[index]; - outputEncoder.Set((inputDecoder.Get() - mean) * gamma / std::sqrt ( var + eps) + beta); - } - - } - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/InstanceNorm.hpp b/src/backends/reference/workloads/InstanceNorm.hpp deleted file mode 100644 index d73b4cd115..0000000000 --- a/src/backends/reference/workloads/InstanceNorm.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Encoders.hpp" -#include "Decoders.hpp" - -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -void InstanceNorm(const InstanceNormalizationQueueDescriptor& data, - Decoder<float>& inputData, - Encoder<float>& outputData); - -} // namespace armnn diff --git a/src/backends/reference/workloads/LogSoftmax.cpp b/src/backends/reference/workloads/LogSoftmax.cpp deleted file mode 100644 index ddf5674fb8..0000000000 --- a/src/backends/reference/workloads/LogSoftmax.cpp +++ /dev/null @@ -1,91 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "LogSoftmax.hpp" - -#include <armnnUtils/TensorUtils.hpp> - -#include <cmath> - -#include <boost/assert.hpp> -#include <boost/core/ignore_unused.hpp> -#include <boost/numeric/conversion/cast.hpp> - -namespace -{ - -inline bool ValidateAxis(int axis, unsigned int numDimensions) -{ - const int sNumDimensions = boost::numeric_cast<int>(numDimensions); - return axis < sNumDimensions && axis >= -sNumDimensions; -} - -} // anonymous namespace - -namespace armnn -{ - -void LogSoftmax(Decoder<float>& input, - Encoder<float>& output, - const TensorInfo& inputInfo, - const LogSoftmaxDescriptor& descriptor) -{ - const unsigned int numDimensions = inputInfo.GetNumDimensions(); - - bool axisIsValid = ValidateAxis(descriptor.m_Axis, numDimensions); - BOOST_ASSERT_MSG(axisIsValid, - "Axis index is not in range [-numDimensions, numDimensions)."); - boost::ignore_unused(axisIsValid); - - unsigned int uAxis = descriptor.m_Axis < 0 ? - numDimensions - boost::numeric_cast<unsigned int>(std::abs(descriptor.m_Axis)) : - boost::numeric_cast<unsigned int>(descriptor.m_Axis); - - const TensorShape& inputShape = inputInfo.GetShape(); - const unsigned int outerSize = armnnUtils::GetNumElementsBetween(inputShape, 0, uAxis); - const unsigned int axisSize = inputShape[uAxis]; - const unsigned int innerSize = armnnUtils::GetNumElementsBetween(inputShape, - uAxis + 1, - inputShape.GetNumDimensions()); - - for (unsigned int outer = 0; outer < outerSize; ++outer) - { - for (unsigned int inner = 0; inner < innerSize; ++inner) - { - // Find max - input[outer * axisSize * innerSize + inner]; - float maxValue = input.Get(); - for (unsigned int i = 1u; i < axisSize; ++i) - { - input[(outer * axisSize + i) * innerSize + inner]; - maxValue = std::max(maxValue, input.Get()); - } - - // Compute sum - float sum = 0.0f; - for (unsigned int i = 0u; i < axisSize; ++i) - { - input[(outer * axisSize + i) * innerSize + inner]; - sum += std::exp((input.Get() - maxValue) * descriptor.m_Beta); - } - - // Compute log sum - const float logSum = std::log(sum); - - // Compute result - for (unsigned int i = 0u; i < axisSize; ++i) - { - const unsigned int index = (outer * axisSize + i) * innerSize + inner; - - input [index]; - output[index]; - - output.Set((input.Get() - maxValue) * descriptor.m_Beta - logSum); - } - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/LogSoftmax.hpp b/src/backends/reference/workloads/LogSoftmax.hpp deleted file mode 100644 index 6d46cb9a24..0000000000 --- a/src/backends/reference/workloads/LogSoftmax.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Descriptors.hpp> -#include <armnn/Tensor.hpp> - -#include "BaseIterator.hpp" - -namespace armnn -{ - -void LogSoftmax(Decoder<float>& input, - Encoder<float>& output, - const TensorInfo& inputInfo, - const LogSoftmaxDescriptor& descriptor); - -} // namespace armnn diff --git a/src/backends/reference/workloads/LstmUtils.cpp b/src/backends/reference/workloads/LstmUtils.cpp deleted file mode 100644 index f197aae291..0000000000 --- a/src/backends/reference/workloads/LstmUtils.cpp +++ /dev/null @@ -1,307 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -//#pragma once - -#include "LstmUtils.hpp" -#include "BaseIterator.hpp" -#include <backendsCommon/CpuTensorHandle.hpp> - - -// Helper functions ported from the Android code base -// Refer to: android/external/tensorflow/tensorflow/contrib/lite/kernels/internal/reference/portable_tensor_utils.cc - -void VectorBatchVectorAdd(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Decoder<float>& batchVector, - uint32_t nBatch, - armnn::Encoder<float>& outResult ) -{ - for (uint32_t b = 0; b < nBatch; b++) - { - for (uint32_t v = 0; v < vSize; v++) - { - outResult.Set(batchVector.Get() + vector.Get()); - ++outResult; - ++vector; - ++batchVector; - } - vector -= vSize; - } - batchVector -= vSize * nBatch; - outResult -= vSize * nBatch; -} - - -// Layer norm for each batch. -// normalization_epsilon is added to avoid divergence. -void MeanStddevNormalization(armnn::Decoder<float>& input_vector, - armnn::Encoder<float>& output_vector, - uint32_t v_size, - uint32_t n_batch, - float normalization_epsilon) -{ - for (uint32_t batch = 0; batch < n_batch; ++batch) { - float sum = 0.0f; - float sum_sq = 0.0f; - for (uint32_t i = 0; i < v_size; ++i) { - sum += input_vector.Get(); - sum_sq += input_vector.Get() * input_vector.Get(); - ++input_vector; - } - input_vector -= v_size; - - const float mean = sum / static_cast<float>(v_size); - float stddev_inv = 0.0f; - const float variance = sum_sq / static_cast<float>(v_size) - mean * mean; - if (variance == 0) { - stddev_inv = 1.0f / std::sqrt(normalization_epsilon); - } else { - stddev_inv = 1.0f / std::sqrt(variance); - } - - for (uint32_t i = 0; i < v_size; ++i) { - output_vector.Set((input_vector.Get() - mean) * stddev_inv); - ++output_vector; - ++input_vector; - } - // Don't reset iterator to handle next batch - } - output_vector -= v_size * n_batch; - input_vector -= v_size * n_batch; -} - -void ZeroVector(armnn::Encoder<float>& vector, - uint32_t vSize) -{ - for (uint32_t v = 0; v < vSize; v++) - { - vector.Set(0.0f); - ++vector; - } - vector -= vSize; -} - -void MatrixBatchVectorMultiplyAccumulate(armnn::Decoder<float>& matrix, - uint32_t mRows, - uint32_t mCols, - armnn::Decoder<float>& vector, - uint32_t nBatch, - armnn::Encoder<float>& outResult) -{ - for (uint32_t b = 0; b < nBatch; b++) - { - for (uint32_t r = 0; r < mRows; r++) - { - vector += b * mCols; - for (uint32_t c = 0; c < mCols; c++) - { - outResult.Set(outResult.Get() + matrix.Get() * vector.Get()); - ++matrix; - ++vector; - } - outResult += 1; - vector -= (b+1) * mCols; - } - matrix -= (mRows * mCols); - } - outResult -= (mRows * nBatch); -} - -void VectorBatchVectorAssign(armnn::Decoder<float>& vector, - uint32_t vSize, - uint32_t nBatch, - armnn::Encoder<float>& outBatchVector) -{ - for (uint32_t b = 0; b < nBatch; b++) - { - for (uint32_t v = 0; v < vSize; v++) - { - outBatchVector.Set(vector.Get()); - ++outBatchVector; - ++vector; - } - vector -= vSize; - } - outBatchVector -= (nBatch * vSize); -} - -void VectorBatchVectorCwiseProductAccumulate(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Decoder<float>& batchVector, - uint32_t nBatch, - armnn::Encoder<float>& outResult) -{ - for (uint32_t b = 0; b < nBatch; b++) - { - for (uint32_t v = 0; v < vSize; v++) - { - outResult.Set(outResult.Get() + vector.Get() * batchVector.Get()); - ++outResult; - ++vector; - ++batchVector; - } - vector -= vSize; - } - batchVector -= vSize * nBatch; - outResult -= vSize * nBatch; -} - -void VectorBatchVectorCwiseProduct(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Decoder<float>& batchVector, - uint32_t nBatch, - armnn::Encoder<float>& outResult) -{ - for (uint32_t b = 0; b < nBatch; b++) - { - for (uint32_t v = 0; v < vSize; v++) - { - outResult.Set(vector.Get() * batchVector.Get()); - ++outResult; - ++vector; - ++batchVector; - } - vector -= vSize; - } - batchVector -= vSize * nBatch; - outResult -= vSize * nBatch; -} - -void Sub1Vector(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Encoder<float>& result) -{ - for (uint32_t v = 0; v < vSize; v++) - { - result.Set(1.0f - vector.Get()); - ++vector; - ++result; - } - vector -= vSize; - result -= vSize; -} - -void VectorVectorCwiseProduct(armnn::Decoder<float>& vector1, - armnn::Decoder<float>& vector2, - uint32_t vSize, - armnn::Encoder<float>& outResult) -{ - for (uint32_t v = 0; v < vSize; v++) - { - outResult.Set(vector1.Get() * vector2.Get()); - ++outResult; - ++vector1; - ++vector2; - } - outResult -= vSize; - vector1 -= vSize; - vector2 -= vSize; -} - -void VectorVectorCwiseProductAccumulate(armnn::Decoder<float>& vector1, - armnn::Decoder<float>& vector2, - uint32_t vSize, - armnn::Encoder<float>& outResult) -{ - for (uint32_t v = 0; v < vSize; v++) - { - outResult.Set(outResult.Get() + vector1.Get() * vector2.Get()); - ++outResult; - ++vector1; - ++vector2; - } - outResult -= vSize; - vector1 -= vSize; - vector2 -= vSize; -} - -float Clip(float f, - float absLimit) -{ - float result = (absLimit < f) ? absLimit : f; - result = (-absLimit > result) ? -absLimit : result; - return result; -} - -void ClipVector(armnn::Decoder<float>& vector, - uint32_t vSize, - float absLimit, - armnn::Encoder<float>& outResult) -{ - for (uint32_t v = 0; v < vSize; v++) - { - outResult.Set(Clip(vector.Get(), absLimit)); - ++vector; - ++outResult; - } - vector -= vSize; - outResult -= vSize; -} - -void CopyVector(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Encoder<float>& outResult) -{ - for (uint32_t v = 0; v < vSize; v++) - { - outResult.Set(vector.Get()); - ++outResult; - ++vector; - } - outResult -= vSize; - vector -= vSize; -} - -void SetActivationParameters(uint32_t activation, - armnn::ActivationFunction& outArmnnActivation, - float& outA, - float& outB) -{ - switch (activation) - { - case 0: // None - outA = 0; - outB = 0; - return; - - case 1: // Relu - outArmnnActivation = armnn::ActivationFunction::ReLu; - outA = 0; - outB = 0; - return; - - case 3: // Relu6 - outArmnnActivation = armnn::ActivationFunction::BoundedReLu; - outA = 6; - outB = 0; - return; - - case 4: // Tanh - outArmnnActivation = armnn::ActivationFunction::TanH; - outA = 1; - outB = 1; - return; - - case 6: // Sigmoid - outArmnnActivation = armnn::ActivationFunction::Sigmoid; - outA = 0; - outB = 0; - return; - - default: - throw armnn::Exception("Unsupported activation function: " + std::to_string(activation)); - } -} - -std::unique_ptr<armnn::ScopedCpuTensorHandle> AssignScopedCpuTensorHandle(const armnn::ConstCpuTensorHandle* ptr) -{ - if (!ptr) - { - return nullptr; - } - - return std::make_unique<armnn::ScopedCpuTensorHandle>(*ptr); -} diff --git a/src/backends/reference/workloads/LstmUtils.hpp b/src/backends/reference/workloads/LstmUtils.hpp deleted file mode 100644 index f6aff8b69f..0000000000 --- a/src/backends/reference/workloads/LstmUtils.hpp +++ /dev/null @@ -1,88 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" -#include <backendsCommon/CpuTensorHandle.hpp> - -// Helper functions ported from the Android code base -// Refer to: android/external/tensorflow/tensorflow/contrib/lite/kernels/internal/reference/portable_tensor_utils.cc - - -void VectorBatchVectorAdd(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Decoder<float>& batchVector, - uint32_t nBatch, - armnn::Encoder<float>& outResult ); - -// Layer norm for each batch. -// normalization_epsilon is added to avoid divergence. -void MeanStddevNormalization(armnn::Decoder<float>& input_vector, - armnn::Encoder<float>& output_vector, - uint32_t v_size, - uint32_t n_batch, - float normalization_epsilon); - -void ZeroVector(armnn::Encoder<float>& vector, - uint32_t vSize); - -void MatrixBatchVectorMultiplyAccumulate(armnn::Decoder<float>& matrix, - uint32_t mRows, - uint32_t mCols, - armnn::Decoder<float>& vector, - uint32_t nBatch, - armnn::Encoder<float>& outResult); - -void VectorBatchVectorAssign(armnn::Decoder<float>& vector, - uint32_t vSize, - uint32_t nBatch, - armnn::Encoder<float>& outBatchVector); - -void VectorBatchVectorCwiseProductAccumulate(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Decoder<float>& batchVector, - uint32_t nBatch, - armnn::Encoder<float>& outResult); - -void VectorBatchVectorCwiseProduct(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Decoder<float>& batchVector, - uint32_t nBatch, - armnn::Encoder<float>& outResult); - -void Sub1Vector(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Encoder<float>& result); - - -void VectorVectorCwiseProduct(armnn::Decoder<float>& vector1, - armnn::Decoder<float>& vector2, - uint32_t vSize, - armnn::Encoder<float>& outResult); - -void VectorVectorCwiseProductAccumulate(armnn::Decoder<float>& vector1, - armnn::Decoder<float>& vector2, - uint32_t vSize, - armnn::Encoder<float>& outResult); - -float Clip(float f, - float absLimit); - -void ClipVector(armnn::Decoder<float>& vector, - uint32_t vSize, - float absLimit, - armnn::Encoder<float>& outResult); - -void CopyVector(armnn::Decoder<float>& vector, - uint32_t vSize, - armnn::Encoder<float>& outResult); - -void SetActivationParameters(uint32_t activation, - armnn::ActivationFunction& outArmnnActivation, - float& outA, - float& outB); - -std::unique_ptr<armnn::ScopedCpuTensorHandle> AssignScopedCpuTensorHandle(const armnn::ConstCpuTensorHandle* ptr); diff --git a/src/backends/reference/workloads/Maximum.hpp b/src/backends/reference/workloads/Maximum.hpp deleted file mode 100644 index 97df19d3c6..0000000000 --- a/src/backends/reference/workloads/Maximum.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <iostream> - -namespace armnn -{ - template<typename T> -struct maximum : public std::binary_function<T, T, T> - { - T - operator () (const T& inputData0, const T& inputData1) const - { - return std::max(inputData0, inputData1); - } - }; - -} //namespace armnn diff --git a/src/backends/reference/workloads/Mean.cpp b/src/backends/reference/workloads/Mean.cpp deleted file mode 100644 index f2c0a4fc3f..0000000000 --- a/src/backends/reference/workloads/Mean.cpp +++ /dev/null @@ -1,143 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Mean.hpp" -#include <backendsCommon/WorkloadData.hpp> - -#include <boost/numeric/conversion/cast.hpp> - -#include <cmath> -#include <cstddef> -#include <functional> -#include <limits> - -namespace armnn -{ -bool NextIndex(const unsigned int numDims, const armnn::TensorShape& dims, std::vector<unsigned int>& current) -{ - unsigned int carry = 1; - - for (unsigned int idx = numDims; idx-- > 0; ) - { - unsigned int current_val = current[idx] + carry; - if (dims[idx] == current_val) - { - current[idx] = 0; - } - else - { - current[idx] = current_val; - carry = 0; - break; - } - } - return (carry == 0); -} - -unsigned int ReducedOutputOffset(const unsigned int numDims, - const armnn::TensorShape& dims, - std::vector<unsigned int>& index, - const unsigned int numAxis, - const std::vector<unsigned int>& axis) -{ - unsigned int offset = 0; - for (unsigned int idx = 0; idx < numDims; ++idx) - { - bool isAxis = false; - if (!axis.empty()) - { - for (unsigned int axisIdx = 0; axisIdx < numAxis; ++axisIdx) - { - if (idx == axis[axisIdx]) - { - isAxis = true; - break; - } - } - } - if (!isAxis) - { - offset = offset * dims[idx] + index[idx]; - } - } - return offset; -} -} // namespace - -namespace armnn -{ -void Mean(const armnn::TensorInfo& inputInfo, - const armnn::TensorInfo& outputInfo, - const std::vector<unsigned int>& axis, - Decoder<float>& input, - Encoder<float>& output) -{ - - unsigned int inputNumDims = inputInfo.GetNumDimensions(); - unsigned int outputNumDims = outputInfo.GetNumDimensions(); - - armnn::TensorShape outputDims = outputInfo.GetShape(); - armnn::TensorShape inputDims = inputInfo.GetShape(); - - // Initialise output data. - unsigned int numOutputs = 1; - for (unsigned int idx = 0; idx < outputNumDims; ++idx) - { - numOutputs *= outputDims[idx]; - } - - std::vector<float> tempSum(numOutputs); - for (unsigned int idx = 0; idx < numOutputs; ++idx) - { - output[idx]; - output.Set(0.0f); - tempSum[idx] = 0.0f; - } - - // Initialise temp index. - std::vector<unsigned int> tempIndex(inputNumDims); - for (unsigned int idx = 0; idx < inputNumDims; ++idx) - { - tempIndex[idx] = 0; - } - - std::vector<unsigned int> resolvedAxis = axis; - if (resolvedAxis.empty()) - { - for (unsigned int idx = 0; idx < inputNumDims; ++idx) - { - resolvedAxis.push_back(idx); - } - } - auto numResolvedAxis = boost::numeric_cast<unsigned int>(resolvedAxis.size()); - - // Iterates through input_data and sum up the reduced axis. - for (bool hasNext = true; hasNext; hasNext = NextIndex(inputNumDims, inputDims, tempIndex)) - { - unsigned int inputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex, 0, {}); - unsigned int outputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex, - numResolvedAxis, resolvedAxis); - input[inputOffset]; - tempSum[outputOffset] += input.Get(); - } - - // Takes average by num of elements added to get mean. - size_t numElementsInAxis = 1; - for (unsigned int idx = 0; idx < numResolvedAxis; ++idx) - { - unsigned int current = inputDims[resolvedAxis[idx]]; - BOOST_ASSERT(boost::numeric_cast<float>(current) < - (std::numeric_limits<float>::max() / boost::numeric_cast<float>(numElementsInAxis))); - numElementsInAxis *= current; - } - if (numElementsInAxis > 0) { - for (unsigned int idx = 0; idx < numOutputs; ++idx) - { - output[idx]; - output.Set(tempSum[idx] / boost::numeric_cast<float>(numElementsInAxis)); - } - } -} -} //namespace armnn diff --git a/src/backends/reference/workloads/Mean.hpp b/src/backends/reference/workloads/Mean.hpp deleted file mode 100644 index dfb0302bf9..0000000000 --- a/src/backends/reference/workloads/Mean.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "armnn/DescriptorsFwd.hpp" -#include "armnn/Tensor.hpp" -#include "BaseIterator.hpp" - -#include <vector> - -namespace armnn -{ -void Mean(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const std::vector<unsigned int>& axis, - Decoder<float>& input, - Encoder<float>& output); -} //namespace armnn - diff --git a/src/backends/reference/workloads/Minimum.hpp b/src/backends/reference/workloads/Minimum.hpp deleted file mode 100644 index 0c053981a0..0000000000 --- a/src/backends/reference/workloads/Minimum.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -namespace armnn -{ - -template<typename T> -struct minimum : public std::binary_function<T, T, T> -{ - T - operator()(const T& input1, const T& input2) const - { - return std::min(input1, input2); - } -}; - -} //namespace armnn - diff --git a/src/backends/reference/workloads/Pad.cpp b/src/backends/reference/workloads/Pad.cpp deleted file mode 100644 index 9fedb44f96..0000000000 --- a/src/backends/reference/workloads/Pad.cpp +++ /dev/null @@ -1,180 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Pad.hpp" -#include <backendsCommon/WorkloadData.hpp> -#include "TensorBufferArrayView.hpp" -#include "Encoders.hpp" - -#include <boost/numeric/conversion/cast.hpp> -#include <cmath> -#include <cstddef> -#include <functional> -#include <limits> -#include <cassert> - -namespace armnn -{ - -template <typename T> -void Pad(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - std::vector<std::pair<unsigned int, unsigned int>> m_padList, - const T* inputData, - T* outData, - const float padValue) -{ - unsigned int numOutputElements = outputInfo.GetNumElements(); - - TensorShape outputShape = outputInfo.GetShape(); - TensorShape inputShape = inputInfo.GetShape(); - - unsigned int numInputDimensions = inputShape.GetNumDimensions(); - - #ifndef NDEBUG - - unsigned int numOutputDimensions = outputShape.GetNumDimensions(); - assert(numInputDimensions == numOutputDimensions); - - #endif - - unsigned int inputBatches = 0; - unsigned int inputChannels = 0; - unsigned int inputHeight = 0; - unsigned int inputWidth = 0; - - unsigned int outputChannels = 0; - unsigned int outputHeight = 0; - unsigned int outputWidth = 0; - - T convertedPadValue = static_cast<T>(padValue); - - for (unsigned int i = 0; i < numOutputElements; ++i) - { - outData[i] = convertedPadValue; - } - - switch(numInputDimensions) { - - case 1: - - inputWidth = inputShape[0]; - - for (unsigned int w = 0; w < inputWidth ; w++) - { - outData[w+std::get<0>(m_padList[0])] = inputData[w]; - } - - break; - - case 2 : - - inputHeight = inputShape[0]; - inputWidth = inputShape[1]; - outputHeight = outputShape[0]; - outputWidth = outputShape[1]; - - for (unsigned int h = 0; h < inputHeight; h++) - { - for (unsigned int w = 0; w < inputWidth ; w++) - { - outData[(h+std::get<0>(m_padList[0]))*outputWidth - + (w+std::get<0>(m_padList[1]))] = inputData[h * inputWidth + w]; - } - } - - break; - - case 3 : - - inputChannels = inputShape[0]; - inputHeight = inputShape[1]; - inputWidth = inputShape[2]; - outputChannels = outputShape[0]; - outputHeight = outputShape[1]; - outputWidth = outputShape[2]; - - for (unsigned int c = 0; c < inputChannels; c++) - { - for (unsigned int h = 0; h < inputHeight; h++) - { - for (unsigned int w = 0; w < inputWidth ; w++) - { - outData[(c+std::get<0>(m_padList[0]))*outputHeight*outputWidth - + (h+std::get<0>(m_padList[1]))*outputWidth - + (w+std::get<0>(m_padList[2]))] = inputData[c * inputHeight * inputWidth - + h * inputWidth - + w]; - } - } - } - - break; - - case 4 : - - inputBatches = inputShape[0]; - inputChannels = inputShape[1]; - inputHeight = inputShape[2]; - inputWidth = inputShape[3]; - outputChannels = outputShape[1]; - outputHeight = outputShape[2]; - outputWidth = outputShape[3]; - - for (unsigned int b = 0; b < inputBatches; b++) - { - for (unsigned int c = 0; c < inputChannels; c++) - { - for (unsigned int h = 0; h < inputHeight; h++) - { - for (unsigned int w = 0; w < inputWidth ; w++) - { - outData[(b+std::get<0>(m_padList[0])) * outputChannels * outputHeight * outputWidth - + (c+std::get<0>(m_padList[1])) * outputHeight * outputWidth - + (h+std::get<0>(m_padList[2])) * outputWidth - + (w+std::get<0>(m_padList[3]))] = inputData[b * inputChannels * inputHeight - * inputWidth - + c * inputHeight * inputWidth - + h * inputWidth - + w]; - } - } - } - } - - break; - - default : - - break; - } -} - -template void Pad<float>(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - std::vector<std::pair<unsigned int, unsigned int>> m_PadList, - const float* inputData, - float* outData, - const float padValue); -template void Pad<Half>(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - std::vector<std::pair<unsigned int, unsigned int>> m_PadList, - const Half* inputData, - Half* outData, - const float padValue); -template void Pad<uint8_t>(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - std::vector<std::pair<unsigned int, unsigned int>> m_PadList, - const uint8_t* inputData, - uint8_t* outData, - const float padValue); -template void Pad<int16_t>(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - std::vector<std::pair<unsigned int, unsigned int>> m_PadList, - const int16_t* inputData, - int16_t* outData, - const float padValue); - -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/Pad.hpp b/src/backends/reference/workloads/Pad.hpp deleted file mode 100644 index 429718596e..0000000000 --- a/src/backends/reference/workloads/Pad.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "armnn/DescriptorsFwd.hpp" -#include "armnn/Tensor.hpp" - -#include <vector> - -namespace armnn -{ -template <typename T> -void Pad(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - std::vector<std::pair<unsigned int, unsigned int>> m_padList, - const T* inputData, - T* outData, - const float padValue); -} //namespace armnn diff --git a/src/backends/reference/workloads/Pooling2d.cpp b/src/backends/reference/workloads/Pooling2d.cpp deleted file mode 100644 index 8ff2eb457a..0000000000 --- a/src/backends/reference/workloads/Pooling2d.cpp +++ /dev/null @@ -1,275 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Pooling2d.hpp" - -#include <armnn/Exceptions.hpp> -#include <armnn/Types.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <boost/numeric/conversion/cast.hpp> - -#include <limits> -#include <algorithm> -#include <functional> - -namespace -{ - using PoolingAlgorithm = armnn::PoolingAlgorithm; - - float DefaultInitializer(PoolingAlgorithm algorithm) - { - switch (algorithm) - { - case PoolingAlgorithm::Max: - { - return std::numeric_limits<float>::lowest(); - } - case PoolingAlgorithm::Average: - case PoolingAlgorithm::L2: - { - return 0.0f; - } - default: - { - throw armnn::InvalidArgumentException("Unsupported pooling algorithm"); - } - } - } - - using Accumulator = std::function<void(float & accu, float value)>; - - Accumulator GetAccumulator(PoolingAlgorithm algorithm) - { - switch (algorithm) - { - case PoolingAlgorithm::Max: - { - return [](float & accu, float value) { - if (value > accu) { - accu = value; - } - }; - } - - case PoolingAlgorithm::Average: - { - return [](float & accu, float value) { - accu += value; - }; - } - - case PoolingAlgorithm::L2: - { - return [](float & accu, float value) { - accu += (value*value); - }; - } - - default: - { - throw armnn::InvalidArgumentException("Unsupported pooling algorithm"); - } - } - } - - using Executor = std::function<void(float & accumulated, float kernelSize)>; - - Executor GetExecutor(PoolingAlgorithm algorithm) - { - switch (algorithm) - { - case PoolingAlgorithm::Max: - { - return [](float & /*accumulated*/, float /*kernelSize*/) {}; - } - - case PoolingAlgorithm::Average: - { - return [](float & accumulated, float kernelSize) { - accumulated /= kernelSize; - }; - } - - case PoolingAlgorithm::L2: - { - return [](float & accumulated, float kernelSize) { - accumulated = sqrtf(accumulated / kernelSize); - }; - } - - default: - { - throw armnn::InvalidArgumentException("Unsupported pooling algorithm"); - } - } - } - - bool OnPaddingOnly(int start, int end, int maxRange) - { - if (end <= 0 || start > maxRange) - { - return true; - } - else - { - return false; - } - } - - - bool ClampRange(int & start, int & end, int maxRange) - { - if (start < 0 || end > maxRange) - { - start = std::min(std::max(start, 0), maxRange); - end = std::min(std::max(end, 0), maxRange); - return true; - } - else - { - return false; - } - } -} - -using namespace armnnUtils; - -namespace armnn -{ -void Pooling2d(Decoder<float>& rInputDecoder, - Encoder<float>& rOutputEncoder, - const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const Pooling2dDescriptor& params) -{ - const DataLayoutIndexed dataLayout(params.m_DataLayout); - auto channelsIndex = dataLayout.GetChannelsIndex(); - auto heightIndex = dataLayout.GetHeightIndex(); - auto widthIndex = dataLayout.GetWidthIndex(); - - const int batchSize = boost::numeric_cast<int>(outputInfo.GetShape()[0]); - const int channels = boost::numeric_cast<int>(outputInfo.GetShape()[channelsIndex]); - const int heightOutput = boost::numeric_cast<int>(outputInfo.GetShape()[heightIndex]); - const int widthOutput = boost::numeric_cast<int>(outputInfo.GetShape()[widthIndex]); - const int heightInput = boost::numeric_cast<int>(inputInfo.GetShape()[heightIndex]); - const int widthInput = boost::numeric_cast<int>(inputInfo.GetShape()[widthIndex]); - const int padLeft = boost::numeric_cast<int>(params.m_PadLeft); - const int padRight = boost::numeric_cast<int>(params.m_PadRight); - const int padTop = boost::numeric_cast<int>(params.m_PadTop); - const int padBottom = boost::numeric_cast<int>(params.m_PadBottom); - const int strideX = boost::numeric_cast<int>(params.m_StrideX); - const int strideY = boost::numeric_cast<int>(params.m_StrideY); - const int poolHeight = boost::numeric_cast<int>(params.m_PoolHeight); - const int poolWidth = boost::numeric_cast<int>(params.m_PoolWidth); - - float defaultInitializer = DefaultInitializer(params.m_PoolType); - - Accumulator accumulate = GetAccumulator(params.m_PoolType); - Executor execute = GetExecutor(params.m_PoolType); - - TensorShape outputShape = outputInfo.GetShape(); - TensorShape inputShape = inputInfo.GetShape(); - - // Check supported padding methods outside the loop to simplify - // the inner loop. - if (params.m_PaddingMethod != PaddingMethod::Exclude && - params.m_PaddingMethod != PaddingMethod::IgnoreValue) - { - throw armnn::InvalidArgumentException("Unsupported padding type"); - } - - for (int n = 0; n < batchSize; n++) - { - for (int c = 0; c < channels; c++) - { - for (int yOutput = 0; yOutput < heightOutput; yOutput++) - { - // Calculate values independent of the x axis - int hstart = (yOutput * strideY) - padTop; - int hend = hstart + poolHeight; - // Clamp the pooling region inside the valid input area (which includes the padding). - // This is necessary because the final pooling in a row may overlap beyond the padding. - hend = std::min(hend, heightInput + padBottom); - - int height = hend - hstart; - bool hclamped = ClampRange(hstart, hend, heightInput); - - for (int xOutput = 0; xOutput < widthOutput; xOutput++) - { - int wstart = (xOutput * strideX) - padLeft; - int wend = wstart + poolWidth; - - // Clamp the pooling region inside the valid input area (which includes the padding). - // This is necessary because the final pooling in a row may overlap beyond the padding. - wend = std::min(wend, widthInput + padRight); - - float result = defaultInitializer; - float poolAreaSize = boost::numeric_cast<float>(height * (wend - wstart)); - - // Special case: when the pooling kernel is over a padding region and the padding - // size is larger or equal to the kernel and the kernel only covers - // padding and no real values, then we initialize the result as zero - // by convention. This is because we need to choose a value here and - // all values we have are padding, which we ignore. - if (OnPaddingOnly(hstart, hend, heightInput) || - OnPaddingOnly(wstart, wend, widthInput)) - { - result = 0.0f; - - unsigned int outputIndex = dataLayout.GetIndex(outputShape, - boost::numeric_cast<unsigned int>(n), - boost::numeric_cast<unsigned int>(c), - boost::numeric_cast<unsigned int>(yOutput), - boost::numeric_cast<unsigned int>(xOutput)); - rOutputEncoder[outputIndex]; - rOutputEncoder.Set(result); - continue; - } - - bool clamped = hclamped |= ClampRange(wstart, wend, widthInput); - - if (clamped && params.m_PaddingMethod == PaddingMethod::Exclude) - { - // When we exclude the padding, it means we calculate with a smaller - // kernel size, so I changed the divisor here. - poolAreaSize = boost::numeric_cast<float>((hend - hstart) * (wend - wstart)); - } - - for (auto yInput = hstart; yInput < hend; yInput++) - { - for (auto xInput = wstart; xInput < wend; xInput++) - { - unsigned int inputIndex = dataLayout.GetIndex(inputShape, - boost::numeric_cast<unsigned int>(n), - boost::numeric_cast<unsigned int>(c), - boost::numeric_cast<unsigned int>(yInput), - boost::numeric_cast<unsigned int>(xInput)); - - rInputDecoder[inputIndex]; - float inval = rInputDecoder.Get(); - - accumulate(result, inval); - } - } - - execute(result, poolAreaSize); - - unsigned int outputIndex = dataLayout.GetIndex(outputShape, - boost::numeric_cast<unsigned int>(n), - boost::numeric_cast<unsigned int>(c), - boost::numeric_cast<unsigned int>(yOutput), - boost::numeric_cast<unsigned int>(xOutput)); - - rOutputEncoder[outputIndex]; - rOutputEncoder.Set(result); - } - } - } - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/Pooling2d.hpp b/src/backends/reference/workloads/Pooling2d.hpp deleted file mode 100644 index 182f9bd262..0000000000 --- a/src/backends/reference/workloads/Pooling2d.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Descriptors.hpp> -#include <armnn/Tensor.hpp> - -#include "BaseIterator.hpp" - -namespace armnn -{ -/// Computes the Pooling2d operation. -void Pooling2d(Decoder<float>& rInputDecoder, - Encoder<float>& rOutputEncoder, - const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const Pooling2dDescriptor& params); -} //namespace armnn diff --git a/src/backends/reference/workloads/PreluImpl.cpp b/src/backends/reference/workloads/PreluImpl.cpp deleted file mode 100644 index 458025bb0a..0000000000 --- a/src/backends/reference/workloads/PreluImpl.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "PreluImpl.hpp" -#include "RefWorkloadUtils.hpp" -#include "Broadcast.hpp" - -namespace armnn -{ - -void PreluImpl(const PreluQueueDescriptor& data, - Decoder<float>& inputData, - Decoder<float>& alphaData, - Encoder<float>& outputData) -{ - const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]); - const TensorInfo& alphaInfo = GetTensorInfo(data.m_Inputs[1]); - const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[0]); - - const TensorShape& inputShape = inputInfo.GetShape(); - const TensorShape& alphaShape = alphaInfo.GetShape(); - const TensorShape& outputShape = outputInfo.GetShape(); - - // PReLU activation: f(x) = alpha * x for x < 0, f(x) = x for x >= 0 - auto prelu = [](float x, float alpha) - { - return x < 0 ? alpha * x : x; - }; - - BroadcastLoop(inputShape, alphaShape, outputShape).Unroll(prelu, 0, inputData, alphaData, outputData); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/PreluImpl.hpp b/src/backends/reference/workloads/PreluImpl.hpp deleted file mode 100644 index 9299b1c7f7..0000000000 --- a/src/backends/reference/workloads/PreluImpl.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Encoders.hpp" -#include "Decoders.hpp" - -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -void PreluImpl(const PreluQueueDescriptor& data, - Decoder<float>& inputData, - Decoder<float>& alphaData, - Encoder<float>& outputData); - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefActivationWorkload.cpp b/src/backends/reference/workloads/RefActivationWorkload.cpp deleted file mode 100644 index 78c971e183..0000000000 --- a/src/backends/reference/workloads/RefActivationWorkload.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefActivationWorkload.hpp" - -#include "Activation.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -namespace armnn -{ - -void RefActivationWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefActivationWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - Activation(*MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()), - *MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()), - inputInfo, - m_Data.m_Parameters.m_Function, - m_Data.m_Parameters.m_A, - m_Data.m_Parameters.m_B); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefActivationWorkload.hpp b/src/backends/reference/workloads/RefActivationWorkload.hpp deleted file mode 100644 index a3b001e61f..0000000000 --- a/src/backends/reference/workloads/RefActivationWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefActivationWorkload : public BaseWorkload<ActivationQueueDescriptor> -{ -public: - using BaseWorkload<ActivationQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefArgMinMaxWorkload.cpp b/src/backends/reference/workloads/RefArgMinMaxWorkload.cpp deleted file mode 100644 index 5f1eb73b61..0000000000 --- a/src/backends/reference/workloads/RefArgMinMaxWorkload.cpp +++ /dev/null @@ -1,38 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefArgMinMaxWorkload.hpp" - -#include "ArgMinMax.hpp" -#include "RefWorkloadUtils.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" -#include "Profiling.hpp" - -namespace armnn -{ -RefArgMinMaxWorkload::RefArgMinMaxWorkload( - const ArgMinMaxQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload<ArgMinMaxQueueDescriptor>(descriptor, info) {} - -void RefArgMinMaxWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefArgMinMaxWorkload_Execute"); - - const TensorInfo &inputTensorInfo = GetTensorInfo(m_Data.m_Inputs[0]); - - std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputTensorInfo, m_Data.m_Inputs[0]->Map()); - Decoder<float> &decoder = *decoderPtr; - - const TensorInfo &outputTensorInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - int32_t* output = GetOutputTensorData<int32_t>(0, m_Data); - - ArgMinMax(decoder, output, inputTensorInfo, outputTensorInfo, m_Data.m_Parameters.m_Function, - m_Data.m_Parameters.m_Axis); -} - -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefArgMinMaxWorkload.hpp b/src/backends/reference/workloads/RefArgMinMaxWorkload.hpp deleted file mode 100644 index 97b70772d1..0000000000 --- a/src/backends/reference/workloads/RefArgMinMaxWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ -class RefArgMinMaxWorkload : public BaseWorkload<ArgMinMaxQueueDescriptor> -{ -public: - explicit RefArgMinMaxWorkload(const ArgMinMaxQueueDescriptor& descriptor, - const WorkloadInfo& info); - - virtual void Execute() const override; -}; -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefBatchNormalizationWorkload.cpp b/src/backends/reference/workloads/RefBatchNormalizationWorkload.cpp deleted file mode 100644 index 54e7d0d38b..0000000000 --- a/src/backends/reference/workloads/RefBatchNormalizationWorkload.cpp +++ /dev/null @@ -1,45 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefBatchNormalizationWorkload.hpp" - -#include "BatchNormImpl.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -namespace armnn -{ - -RefBatchNormalizationWorkload::RefBatchNormalizationWorkload(const BatchNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload(descriptor, info) - , m_Mean (std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Mean))) - , m_Variance(std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Variance))) - , m_Beta (std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Beta))) - , m_Gamma (std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Gamma))) -{} - -void RefBatchNormalizationWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefBatchNormalizationWorkload_Execute"); - - std::unique_ptr<Decoder<float>> meanDecoder = MakeDecoder<float>(m_Mean->GetTensorInfo(), - m_Mean->Map(true)); - std::unique_ptr<Decoder<float>> varianceDecoder = MakeDecoder<float>(m_Variance->GetTensorInfo(), - m_Variance->Map(true)); - std::unique_ptr<Decoder<float>> gammaDecoder = MakeDecoder<float>(m_Gamma->GetTensorInfo(), - m_Gamma->Map(true)); - std::unique_ptr<Decoder<float>> betaDecoder = MakeDecoder<float>(m_Beta->GetTensorInfo(), - m_Beta->Map(true)); - std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(GetTensorInfo(m_Data.m_Inputs[0]), - m_Data.m_Inputs[0]->Map()); - std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(m_Data.m_Outputs[0]), - m_Data.m_Outputs[0]->Map()); - - BatchNormImpl(m_Data, *meanDecoder, *varianceDecoder, *betaDecoder, *gammaDecoder, *inputDecoder, *outputEncoder); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefBatchNormalizationWorkload.hpp b/src/backends/reference/workloads/RefBatchNormalizationWorkload.hpp deleted file mode 100644 index 9e71e7b4c5..0000000000 --- a/src/backends/reference/workloads/RefBatchNormalizationWorkload.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefBatchNormalizationWorkload : public BaseWorkload<BatchNormalizationQueueDescriptor> -{ -public: - explicit RefBatchNormalizationWorkload(const BatchNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info); - virtual void Execute() const override; - -private: - std::unique_ptr<ScopedCpuTensorHandle> m_Mean; - std::unique_ptr<ScopedCpuTensorHandle> m_Variance; - std::unique_ptr<ScopedCpuTensorHandle> m_Beta; - std::unique_ptr<ScopedCpuTensorHandle> m_Gamma; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefBatchToSpaceNdWorkload.cpp b/src/backends/reference/workloads/RefBatchToSpaceNdWorkload.cpp deleted file mode 100644 index c21ef7640a..0000000000 --- a/src/backends/reference/workloads/RefBatchToSpaceNdWorkload.cpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "BatchToSpaceNd.hpp" -#include "Profiling.hpp" -#include "RefBatchToSpaceNdWorkload.hpp" -#include "RefWorkloadUtils.hpp" - -namespace armnn -{ - -void RefBatchToSpaceNdWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefBatchToSpaceNdWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - BatchToSpaceNd(m_Data.m_Parameters.m_DataLayout, inputInfo, outputInfo, m_Data.m_Parameters.m_BlockShape, - m_Data.m_Parameters.m_Crops, *inputDecoder, *outputEncoder); -} - - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefBatchToSpaceNdWorkload.hpp b/src/backends/reference/workloads/RefBatchToSpaceNdWorkload.hpp deleted file mode 100644 index 60577bab2e..0000000000 --- a/src/backends/reference/workloads/RefBatchToSpaceNdWorkload.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn { - -class RefBatchToSpaceNdWorkload : public BaseWorkload<BatchToSpaceNdQueueDescriptor> -{ - -public: - using BaseWorkload<BatchToSpaceNdQueueDescriptor>::BaseWorkload; - - virtual void Execute() const override; -}; - -} // namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefComparisonWorkload.cpp b/src/backends/reference/workloads/RefComparisonWorkload.cpp deleted file mode 100644 index 52ad9a2879..0000000000 --- a/src/backends/reference/workloads/RefComparisonWorkload.cpp +++ /dev/null @@ -1,102 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefComparisonWorkload.hpp" - -#include "Decoders.hpp" -#include "ElementwiseFunction.hpp" -#include "Encoders.hpp" -#include "RefWorkloadUtils.hpp" - -#include <Profiling.hpp> - -#include <armnn/TypesUtils.hpp> - -#include <functional> - -namespace armnn -{ - -RefComparisonWorkload::RefComparisonWorkload(const ComparisonQueueDescriptor& desc, - const WorkloadInfo& info) - : BaseWorkload<ComparisonQueueDescriptor>(desc, info) -{} - -void RefComparisonWorkload::PostAllocationConfigure() -{ - const TensorInfo& inputInfo0 = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& inputInfo1 = GetTensorInfo(m_Data.m_Inputs[1]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - m_Input0 = MakeDecoder<InType>(inputInfo0); - m_Input1 = MakeDecoder<InType>(inputInfo1); - - m_Output = MakeEncoder<OutType>(outputInfo); -} - -void RefComparisonWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefComparisonWorkload_Execute"); - - const TensorInfo& inputInfo0 = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& inputInfo1 = GetTensorInfo(m_Data.m_Inputs[1]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - const TensorShape& inShape0 = inputInfo0.GetShape(); - const TensorShape& inShape1 = inputInfo1.GetShape(); - const TensorShape& outShape = outputInfo.GetShape(); - - m_Input0->Reset(m_Data.m_Inputs[0]->Map()); - m_Input1->Reset(m_Data.m_Inputs[1]->Map()); - m_Output->Reset(m_Data.m_Outputs[0]->Map()); - - using EqualFunction = ElementwiseBinaryFunction<std::equal_to<InType>>; - using GreaterFunction = ElementwiseBinaryFunction<std::greater<InType>>; - using GreaterOrEqualFunction = ElementwiseBinaryFunction<std::greater_equal<InType>>; - using LessFunction = ElementwiseBinaryFunction<std::less<InType>>; - using LessOrEqualFunction = ElementwiseBinaryFunction<std::less_equal<InType>>; - using NotEqualFunction = ElementwiseBinaryFunction<std::not_equal_to<InType>>; - - switch (m_Data.m_Parameters.m_Operation) - { - case ComparisonOperation::Equal: - { - EqualFunction(inShape0, inShape1, outShape, *m_Input0, *m_Input1, *m_Output); - break; - } - case ComparisonOperation::Greater: - { - GreaterFunction(inShape0, inShape1, outShape, *m_Input0, *m_Input1, *m_Output); - break; - } - case ComparisonOperation::GreaterOrEqual: - { - GreaterOrEqualFunction(inShape0, inShape1, outShape, *m_Input0, *m_Input1, *m_Output); - break; - } - case ComparisonOperation::Less: - { - LessFunction(inShape0, inShape1, outShape, *m_Input0, *m_Input1, *m_Output); - break; - } - case ComparisonOperation::LessOrEqual: - { - LessOrEqualFunction(inShape0, inShape1, outShape, *m_Input0, *m_Input1, *m_Output); - break; - } - case ComparisonOperation::NotEqual: - { - NotEqualFunction(inShape0, inShape1, outShape, *m_Input0, *m_Input1, *m_Output); - break; - } - default: - { - throw InvalidArgumentException(std::string("Unsupported comparison operation ") + - GetComparisonOperationAsCString(m_Data.m_Parameters.m_Operation), CHECK_LOCATION()); - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefComparisonWorkload.hpp b/src/backends/reference/workloads/RefComparisonWorkload.hpp deleted file mode 100644 index a19e4a0540..0000000000 --- a/src/backends/reference/workloads/RefComparisonWorkload.hpp +++ /dev/null @@ -1,34 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefComparisonWorkload : public BaseWorkload<ComparisonQueueDescriptor> -{ -public: - using BaseWorkload<ComparisonQueueDescriptor>::m_Data; - - RefComparisonWorkload(const ComparisonQueueDescriptor& descriptor, const WorkloadInfo& info); - void PostAllocationConfigure() override; - void Execute() const override; - -private: - using InType = float; - using OutType = bool; - - std::unique_ptr<Decoder<InType>> m_Input0; - std::unique_ptr<Decoder<InType>> m_Input1; - std::unique_ptr<Encoder<OutType>> m_Output; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefConcatWorkload.cpp b/src/backends/reference/workloads/RefConcatWorkload.cpp deleted file mode 100644 index 152eae93b3..0000000000 --- a/src/backends/reference/workloads/RefConcatWorkload.cpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefConcatWorkload.hpp" - -#include "Concatenate.hpp" - -#include "Profiling.hpp" - -namespace armnn -{ - -void RefConcatWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefConcatWorkload_Execute"); - Concatenate(m_Data); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConcatWorkload.hpp b/src/backends/reference/workloads/RefConcatWorkload.hpp deleted file mode 100644 index 7d0b6b7cd1..0000000000 --- a/src/backends/reference/workloads/RefConcatWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefConcatWorkload : public BaseWorkload<ConcatQueueDescriptor> -{ -public: - using BaseWorkload<ConcatQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConstantWorkload.cpp b/src/backends/reference/workloads/RefConstantWorkload.cpp deleted file mode 100644 index 3506198410..0000000000 --- a/src/backends/reference/workloads/RefConstantWorkload.cpp +++ /dev/null @@ -1,41 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefConstantWorkload.hpp" - -#include "RefWorkloadUtils.hpp" - -#include <armnn/Types.hpp> - -#include <boost/assert.hpp> - -#include <cstring> - -namespace armnn -{ - -RefConstantWorkload::RefConstantWorkload( - const ConstantQueueDescriptor& descriptor, const WorkloadInfo& info) - : BaseWorkload<ConstantQueueDescriptor>(descriptor, info) {} - -void RefConstantWorkload::PostAllocationConfigure() -{ - const ConstantQueueDescriptor& data = this->m_Data; - - BOOST_ASSERT(data.m_LayerOutput != nullptr); - - const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[0]); - BOOST_ASSERT(data.m_LayerOutput->GetTensorInfo().GetNumBytes() == outputInfo.GetNumBytes()); - - memcpy(GetOutputTensorData<void>(0, data), data.m_LayerOutput->GetConstTensor<void>(), - outputInfo.GetNumBytes()); -} - -void RefConstantWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefConstantWorkload_Execute"); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConstantWorkload.hpp b/src/backends/reference/workloads/RefConstantWorkload.hpp deleted file mode 100644 index ada488a7b2..0000000000 --- a/src/backends/reference/workloads/RefConstantWorkload.hpp +++ /dev/null @@ -1,26 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -#include <armnn/Types.hpp> - -namespace armnn -{ - -// Base class template providing an implementation of the Constant layer common to all data types. -class RefConstantWorkload : public BaseWorkload<ConstantQueueDescriptor> -{ -public: - RefConstantWorkload(const ConstantQueueDescriptor& descriptor, const WorkloadInfo& info); - - void PostAllocationConfigure() override; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConvertFp16ToFp32Workload.cpp b/src/backends/reference/workloads/RefConvertFp16ToFp32Workload.cpp deleted file mode 100644 index ef813eb69b..0000000000 --- a/src/backends/reference/workloads/RefConvertFp16ToFp32Workload.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefConvertFp16ToFp32Workload.hpp" -#include "RefWorkloadUtils.hpp" - -#include <armnnUtils/FloatingPointConverter.hpp> - -#include <Half.hpp> - -namespace armnn -{ - -void RefConvertFp16ToFp32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefConvertFp16ToFp32Workload_Execute"); - - const Half* const input = GetInputTensorDataHalf(0, m_Data); - float* const output = GetOutputTensorDataFloat(0, m_Data); - - unsigned int numElements = GetTensorInfo(m_Data.m_Inputs[0]).GetNumElements(); - armnnUtils::FloatingPointConverter::ConvertFloat16To32(input, numElements, output); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConvertFp16ToFp32Workload.hpp b/src/backends/reference/workloads/RefConvertFp16ToFp32Workload.hpp deleted file mode 100644 index 7c58e9f089..0000000000 --- a/src/backends/reference/workloads/RefConvertFp16ToFp32Workload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefConvertFp16ToFp32Workload : public Float16ToFloat32Workload<ConvertFp16ToFp32QueueDescriptor> -{ -public: - using Float16ToFloat32Workload<ConvertFp16ToFp32QueueDescriptor>::Float16ToFloat32Workload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConvertFp32ToFp16Workload.cpp b/src/backends/reference/workloads/RefConvertFp32ToFp16Workload.cpp deleted file mode 100644 index 559901f2f2..0000000000 --- a/src/backends/reference/workloads/RefConvertFp32ToFp16Workload.cpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefConvertFp32ToFp16Workload.hpp" -#include "RefWorkloadUtils.hpp" -#include "Profiling.hpp" - -#include <armnnUtils/FloatingPointConverter.hpp> - -#include <Half.hpp> - -namespace armnn -{ - -void RefConvertFp32ToFp16Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefConvertFp32ToFp16Workload_Execute"); - - const float* const input = GetInputTensorDataFloat(0, m_Data); - Half* const output = GetOutputTensorDataHalf(0, m_Data); - - // convert Fp32 input to Fp16 output - unsigned int numElements = GetTensorInfo(m_Data.m_Inputs[0]).GetNumElements(); - armnnUtils::FloatingPointConverter::ConvertFloat32To16(input, numElements, output); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConvertFp32ToFp16Workload.hpp b/src/backends/reference/workloads/RefConvertFp32ToFp16Workload.hpp deleted file mode 100644 index 283766dfb5..0000000000 --- a/src/backends/reference/workloads/RefConvertFp32ToFp16Workload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefConvertFp32ToFp16Workload : public Float32ToFloat16Workload<ConvertFp32ToFp16QueueDescriptor> -{ -public: - using Float32ToFloat16Workload<ConvertFp32ToFp16QueueDescriptor>::Float32ToFloat16Workload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConvolution2dWorkload.cpp b/src/backends/reference/workloads/RefConvolution2dWorkload.cpp deleted file mode 100644 index dad9936f1b..0000000000 --- a/src/backends/reference/workloads/RefConvolution2dWorkload.cpp +++ /dev/null @@ -1,57 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefConvolution2dWorkload.hpp" - -#include "ConvImpl.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -namespace armnn -{ -RefConvolution2dWorkload::RefConvolution2dWorkload( - const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) - : BaseWorkload<Convolution2dQueueDescriptor>(descriptor, info) -{ - m_Weight = std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Weight)); - const TensorInfo& rFilterInfo = m_Weight->GetTensorInfo(); - - m_FilterShape = rFilterInfo.GetShape(); - m_FilterDecoder = MakeDecoder<float>(rFilterInfo, m_Weight.get()->Map(true)); - - if (descriptor.m_Parameters.m_BiasEnabled) - { - m_Bias = std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Bias)); - const TensorInfo& biasInfo = m_Bias->GetTensorInfo(); - m_BiasDecoder = MakeDecoder<float>(biasInfo, m_Bias->Map(true)); - } -} - -void RefConvolution2dWorkload::PostAllocationConfigure() -{ - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - m_InputShape = inputInfo.GetShape(); - m_InputDecoder = MakeDecoder<float>(inputInfo); - - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - m_OutputShape = outputInfo.GetShape(); - m_OutputEncoder = MakeEncoder<float>(outputInfo); -} - -void RefConvolution2dWorkload::Execute() const { - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefConvolution2dWorkload_Execute"); - - m_InputDecoder->Reset(m_Data.m_Inputs[0]->Map()); - m_OutputEncoder->Reset(m_Data.m_Outputs[0]->Map()); - - Convolve(m_InputShape, *m_InputDecoder, m_OutputShape, *m_OutputEncoder, m_FilterShape, - *m_FilterDecoder, m_Data.m_Parameters.m_BiasEnabled, m_BiasDecoder.get(), - m_Data.m_Parameters.m_DataLayout, m_Data.m_Parameters.m_PadTop, m_Data.m_Parameters.m_PadLeft, - m_Data.m_Parameters.m_StrideX, m_Data.m_Parameters.m_StrideY, - m_Data.m_Parameters.m_DilationX, m_Data.m_Parameters.m_DilationY); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefConvolution2dWorkload.hpp b/src/backends/reference/workloads/RefConvolution2dWorkload.hpp deleted file mode 100644 index b6bdf23ffa..0000000000 --- a/src/backends/reference/workloads/RefConvolution2dWorkload.hpp +++ /dev/null @@ -1,41 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -class RefConvolution2dWorkload : public BaseWorkload<Convolution2dQueueDescriptor> -{ -public: - explicit RefConvolution2dWorkload(const Convolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info); - - void PostAllocationConfigure() override; - - virtual void Execute() const override; - -private: - std::unique_ptr<ScopedCpuTensorHandle> m_Weight; - std::unique_ptr<ScopedCpuTensorHandle> m_Bias; - - std::unique_ptr<Decoder<float>> m_InputDecoder; - std::unique_ptr<Encoder<float>> m_OutputEncoder; - std::unique_ptr<Decoder<float>> m_FilterDecoder; - std::unique_ptr<Decoder<float>> m_BiasDecoder; - - TensorShape m_InputShape; - TensorShape m_OutputShape; - TensorShape m_FilterShape; -}; - -} //namespace armnn - diff --git a/src/backends/reference/workloads/RefDebugWorkload.cpp b/src/backends/reference/workloads/RefDebugWorkload.cpp deleted file mode 100644 index af714a3ca7..0000000000 --- a/src/backends/reference/workloads/RefDebugWorkload.cpp +++ /dev/null @@ -1,55 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefDebugWorkload.hpp" -#include "Debug.hpp" -#include "RefWorkloadUtils.hpp" - -#include <ResolveType.hpp> - -#include <cstring> - -namespace armnn -{ - -template<armnn::DataType DataType> -void RefDebugWorkload<DataType>::Execute() const -{ - using T = ResolveType<DataType>; - - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, GetName() + "_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - - const T* inputData = GetInputTensorData<T>(0, m_Data); - T* outputData = GetOutputTensorData<T>(0, m_Data); - - if (m_Callback) - { - m_Callback(m_Data.m_Guid, m_Data.m_SlotIndex, m_Data.m_Inputs[0]); - } - else - { - Debug(inputInfo, inputData, m_Data.m_Guid, m_Data.m_LayerName, m_Data.m_SlotIndex); - } - - std::memcpy(outputData, inputData, inputInfo.GetNumElements()*sizeof(T)); -} - -template<armnn::DataType DataType> -void RefDebugWorkload<DataType>::RegisterDebugCallback(const DebugCallbackFunction& func) -{ - m_Callback = func; -} - -template class RefDebugWorkload<DataType::Float16>; -template class RefDebugWorkload<DataType::Float32>; -template class RefDebugWorkload<DataType::QAsymmU8>; -template class RefDebugWorkload<DataType::QAsymmS8>; -template class RefDebugWorkload<DataType::QSymmS16>; -template class RefDebugWorkload<DataType::QSymmS8>; -template class RefDebugWorkload<DataType::Signed32>; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefDebugWorkload.hpp b/src/backends/reference/workloads/RefDebugWorkload.hpp deleted file mode 100644 index 5a2a1cdf1b..0000000000 --- a/src/backends/reference/workloads/RefDebugWorkload.hpp +++ /dev/null @@ -1,48 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/TypesUtils.hpp> - -#include <backendsCommon/Workload.hpp> - -namespace armnn -{ - -template <armnn::DataType DataType> -class RefDebugWorkload : public TypedWorkload<DebugQueueDescriptor, DataType> -{ -public: - RefDebugWorkload(const DebugQueueDescriptor& descriptor, const WorkloadInfo& info) - : TypedWorkload<DebugQueueDescriptor, DataType>(descriptor, info) - , m_Callback(nullptr) {} - - static const std::string& GetName() - { - static const std::string name = std::string("RefDebug") + GetDataTypeName(DataType) + "Workload"; - return name; - } - - using TypedWorkload<DebugQueueDescriptor, DataType>::m_Data; - using TypedWorkload<DebugQueueDescriptor, DataType>::TypedWorkload; - - void Execute() const override; - - void RegisterDebugCallback(const DebugCallbackFunction& func) override; - -private: - DebugCallbackFunction m_Callback; -}; - -using RefDebugFloat16Workload = RefDebugWorkload<DataType::Float16>; -using RefDebugFloat32Workload = RefDebugWorkload<DataType::Float32>; -using RefDebugQAsymmU8Workload = RefDebugWorkload<DataType::QAsymmU8>; -using RefDebugQAsymmS8Workload = RefDebugWorkload<DataType::QAsymmS8>; -using RefDebugQSymmS16Workload = RefDebugWorkload<DataType::QSymmS16>; -using RefDebugQSymmS8Workload = RefDebugWorkload<DataType::QSymmS8>; -using RefDebugSigned32Workload = RefDebugWorkload<DataType::Signed32>; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefDepthToSpaceWorkload.cpp b/src/backends/reference/workloads/RefDepthToSpaceWorkload.cpp deleted file mode 100644 index 93c1120a1c..0000000000 --- a/src/backends/reference/workloads/RefDepthToSpaceWorkload.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefDepthToSpaceWorkload.hpp" - -#include "DepthToSpace.hpp" -#include "RefWorkloadUtils.hpp" - -namespace armnn -{ - -void RefDepthToSpaceWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefDepthToSpaceWorkload_Execute"); - - const TensorInfo inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - - DepthToSpace(inputInfo, - m_Data.m_Parameters, - m_Data.m_Inputs[0]->Map(), - m_Data.m_Outputs[0]->Map(), - GetDataTypeSize(inputInfo.GetDataType())); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefDepthToSpaceWorkload.hpp b/src/backends/reference/workloads/RefDepthToSpaceWorkload.hpp deleted file mode 100644 index a30fadc3e9..0000000000 --- a/src/backends/reference/workloads/RefDepthToSpaceWorkload.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> - -namespace armnn -{ - -class RefDepthToSpaceWorkload : public BaseWorkload<DepthToSpaceQueueDescriptor> -{ -public: - using BaseWorkload<DepthToSpaceQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.cpp b/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.cpp deleted file mode 100644 index cfc81ce203..0000000000 --- a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.cpp +++ /dev/null @@ -1,62 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefDepthwiseConvolution2dWorkload.hpp" - -#include "ConvImpl.hpp" -#include "RefWorkloadUtils.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" -#include "Profiling.hpp" -#include <ResolveType.hpp> - -namespace armnn -{ - -RefDepthwiseConvolution2dWorkload::RefDepthwiseConvolution2dWorkload( - const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) - : BaseWorkload<DepthwiseConvolution2dQueueDescriptor>(descriptor, info) -{ - m_Weight = std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Weight)); - const TensorInfo& rFilterInfo = m_Weight->GetTensorInfo(); - m_FilterShape = rFilterInfo.GetShape(); - m_FilterDecoder = MakeDecoder<float>(rFilterInfo, m_Weight->Map(true)); - - if (descriptor.m_Parameters.m_BiasEnabled) - { - m_Bias = std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Bias)); - const TensorInfo& biasInfo = m_Bias->GetTensorInfo(); - m_BiasDecoder = MakeDecoder<float>(biasInfo, m_Bias->Map(true)); - } -} - -void RefDepthwiseConvolution2dWorkload::PostAllocationConfigure() -{ - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - m_InputShape = inputInfo.GetShape(); - m_InputDecoder = MakeDecoder<float>(inputInfo); - - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - m_OutputShape = outputInfo.GetShape(); - m_OutputEncoder = MakeEncoder<float>(outputInfo); -} - -void RefDepthwiseConvolution2dWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefDepthwiseConvolution2dWorkload_Execute"); - std::unique_ptr<Decoder<float>> pBiasDecoder{}; - - m_InputDecoder->Reset(m_Data.m_Inputs[0]->Map()); - m_OutputEncoder->Reset(m_Data.m_Outputs[0]->Map()); - - Convolve(m_InputShape, *m_InputDecoder, m_OutputShape, *m_OutputEncoder, - m_FilterShape, *m_FilterDecoder, m_Data.m_Parameters.m_BiasEnabled, m_BiasDecoder.get(), - m_Data.m_Parameters.m_DataLayout, m_Data.m_Parameters.m_PadTop, m_Data.m_Parameters.m_PadLeft, - m_Data.m_Parameters.m_StrideX, m_Data.m_Parameters.m_StrideY, - m_Data.m_Parameters.m_DilationX, - m_Data.m_Parameters.m_DilationY, true); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.hpp b/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.hpp deleted file mode 100644 index 6d7037f660..0000000000 --- a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.hpp +++ /dev/null @@ -1,39 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <armnn/TypesUtils.hpp> - -namespace armnn -{ - -class RefDepthwiseConvolution2dWorkload : public BaseWorkload<DepthwiseConvolution2dQueueDescriptor> { -public: - explicit RefDepthwiseConvolution2dWorkload(const DepthwiseConvolution2dQueueDescriptor &descriptor, - const WorkloadInfo &info); - - void PostAllocationConfigure() override; - - virtual void Execute() const override; - -private: - - std::unique_ptr <ScopedCpuTensorHandle> m_Weight; - std::unique_ptr <ScopedCpuTensorHandle> m_Bias; - - std::unique_ptr <Decoder<float>> m_InputDecoder; - std::unique_ptr <Encoder<float>> m_OutputEncoder; - std::unique_ptr <Decoder<float>> m_FilterDecoder; - std::unique_ptr <Decoder<float>> m_BiasDecoder; - - TensorShape m_InputShape; - TensorShape m_OutputShape; - TensorShape m_FilterShape; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefDequantizeWorkload.cpp b/src/backends/reference/workloads/RefDequantizeWorkload.cpp deleted file mode 100644 index e6f5c6b359..0000000000 --- a/src/backends/reference/workloads/RefDequantizeWorkload.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefDequantizeWorkload.hpp" -#include "RefWorkloadUtils.hpp" -#include "Encoders.hpp" -#include "Decoders.hpp" -#include "Dequantize.hpp" - -namespace armnn -{ - -void RefDequantizeWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefDequantizeWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - auto inputDecoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - auto outputEncoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - Dequantize(*inputDecoder, *outputEncoder, inputInfo, outputInfo); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefDequantizeWorkload.hpp b/src/backends/reference/workloads/RefDequantizeWorkload.hpp deleted file mode 100644 index 8d019e3220..0000000000 --- a/src/backends/reference/workloads/RefDequantizeWorkload.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> - -namespace armnn -{ - -class RefDequantizeWorkload : public BaseWorkload<DequantizeQueueDescriptor> -{ -public: - using BaseWorkload<DequantizeQueueDescriptor>::m_Data; - using BaseWorkload<DequantizeQueueDescriptor>::BaseWorkload; - - void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.cpp b/src/backends/reference/workloads/RefDetectionPostProcessWorkload.cpp deleted file mode 100644 index b9817ba1ea..0000000000 --- a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.cpp +++ /dev/null @@ -1,50 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefDetectionPostProcessWorkload.hpp" - -#include "Decoders.hpp" -#include "DetectionPostProcess.hpp" -#include "Profiling.hpp" -#include "RefWorkloadUtils.hpp" - -namespace armnn -{ - -RefDetectionPostProcessWorkload::RefDetectionPostProcessWorkload( - const DetectionPostProcessQueueDescriptor& descriptor, const WorkloadInfo& info) - : BaseWorkload<DetectionPostProcessQueueDescriptor>(descriptor, info), - m_Anchors(std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Anchors))) {} - -void RefDetectionPostProcessWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefDetectionPostProcessWorkload_Execute"); - - const TensorInfo& boxEncodingsInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& scoresInfo = GetTensorInfo(m_Data.m_Inputs[1]); - const TensorInfo& anchorsInfo = m_Anchors->GetTensorInfo(); - - const TensorInfo& detectionBoxesInfo = GetTensorInfo(m_Data.m_Outputs[0]); - const TensorInfo& detectionClassesInfo = GetTensorInfo(m_Data.m_Outputs[1]); - const TensorInfo& detectionScoresInfo = GetTensorInfo(m_Data.m_Outputs[2]); - const TensorInfo& numDetectionsInfo = GetTensorInfo(m_Data.m_Outputs[3]); - - auto boxEncodings = MakeDecoder<float>(boxEncodingsInfo, m_Data.m_Inputs[0]->Map()); - auto scores = MakeDecoder<float>(scoresInfo, m_Data.m_Inputs[1]->Map()); - auto anchors = MakeDecoder<float>(anchorsInfo, m_Anchors->Map(false)); - - float* detectionBoxes = GetOutputTensorData<float>(0, m_Data); - float* detectionClasses = GetOutputTensorData<float>(1, m_Data); - float* detectionScores = GetOutputTensorData<float>(2, m_Data); - float* numDetections = GetOutputTensorData<float>(3, m_Data); - - DetectionPostProcess(boxEncodingsInfo, scoresInfo, anchorsInfo, - detectionBoxesInfo, detectionClassesInfo, - detectionScoresInfo, numDetectionsInfo, m_Data.m_Parameters, - *boxEncodings, *scores, *anchors, detectionBoxes, - detectionClasses, detectionScores, numDetections); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.hpp b/src/backends/reference/workloads/RefDetectionPostProcessWorkload.hpp deleted file mode 100644 index 799d0c6219..0000000000 --- a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefDetectionPostProcessWorkload : public BaseWorkload<DetectionPostProcessQueueDescriptor> -{ -public: - explicit RefDetectionPostProcessWorkload(const DetectionPostProcessQueueDescriptor& descriptor, - const WorkloadInfo& info); - virtual void Execute() const override; - -private: - std::unique_ptr<ScopedCpuTensorHandle> m_Anchors; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefElementwiseUnaryWorkload.cpp b/src/backends/reference/workloads/RefElementwiseUnaryWorkload.cpp deleted file mode 100644 index 4fbb0d123f..0000000000 --- a/src/backends/reference/workloads/RefElementwiseUnaryWorkload.cpp +++ /dev/null @@ -1,95 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefElementwiseUnaryWorkload.hpp" - -#include "Decoders.hpp" -#include "ElementwiseFunction.hpp" -#include "Encoders.hpp" -#include "RefWorkloadUtils.hpp" -#include "Abs.hpp" -#include "Exp.hpp" -#include "Rsqrt.hpp" -#include "Sqrt.hpp" - -#include <Profiling.hpp> - -#include <armnn/TypesUtils.hpp> - -#include <functional> - -namespace armnn -{ - -RefElementwiseUnaryWorkload::RefElementwiseUnaryWorkload(const ElementwiseUnaryQueueDescriptor& desc, - const WorkloadInfo& info) - : BaseWorkload<ElementwiseUnaryQueueDescriptor>(desc, info) -{} - -void RefElementwiseUnaryWorkload::PostAllocationConfigure() -{ - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - m_Input = MakeDecoder<InType>(inputInfo); - - m_Output = MakeEncoder<OutType>(outputInfo); -} - -void RefElementwiseUnaryWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefElementwiseUnaryWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - const TensorShape& inShape = inputInfo.GetShape(); - const TensorShape& outShape = outputInfo.GetShape(); - - m_Input->Reset(m_Data.m_Inputs[0]->Map()); - m_Output->Reset(m_Data.m_Outputs[0]->Map()); - - using AbsFunction = ElementwiseUnaryFunction<abs<InType>>; - using ExpFunction = ElementwiseUnaryFunction<exp<InType>>; - using NegFunction = ElementwiseUnaryFunction<std::negate<InType>>; - using RsqrtFunction = ElementwiseUnaryFunction<rsqrt<InType>>; - using SqrtFunction = ElementwiseUnaryFunction<sqrt<InType>>; - - switch (m_Data.m_Parameters.m_Operation) - { - case UnaryOperation::Abs: - { - AbsFunction(inShape, outShape, *m_Input, *m_Output); - break; - } - case UnaryOperation::Exp: - { - ExpFunction(inShape, outShape, *m_Input, *m_Output); - break; - } - case UnaryOperation::Neg: - { - NegFunction(inShape, outShape, *m_Input, *m_Output); - break; - } - case UnaryOperation::Rsqrt: - { - RsqrtFunction(inShape, outShape, *m_Input, *m_Output); - break; - } - case UnaryOperation::Sqrt: - { - SqrtFunction(inShape, outShape, *m_Input, *m_Output); - break; - } - default: - { - throw InvalidArgumentException(std::string("Unsupported unary operation ") + - GetUnaryOperationAsCString(m_Data.m_Parameters.m_Operation), CHECK_LOCATION()); - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefElementwiseUnaryWorkload.hpp b/src/backends/reference/workloads/RefElementwiseUnaryWorkload.hpp deleted file mode 100644 index efb2865ebd..0000000000 --- a/src/backends/reference/workloads/RefElementwiseUnaryWorkload.hpp +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefElementwiseUnaryWorkload : public BaseWorkload<ElementwiseUnaryQueueDescriptor> -{ -public: - using BaseWorkload<ElementwiseUnaryQueueDescriptor>::m_Data; - - RefElementwiseUnaryWorkload(const ElementwiseUnaryQueueDescriptor& descriptor, const WorkloadInfo& info); - void PostAllocationConfigure() override; - void Execute() const override; - -private: - using InType = float; - using OutType = float; - - std::unique_ptr<Decoder<InType>> m_Input; - std::unique_ptr<Encoder<OutType>> m_Output; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefElementwiseWorkload.cpp b/src/backends/reference/workloads/RefElementwiseWorkload.cpp deleted file mode 100644 index 18bf0a7ad9..0000000000 --- a/src/backends/reference/workloads/RefElementwiseWorkload.cpp +++ /dev/null @@ -1,88 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefElementwiseWorkload.hpp" - -#include "Decoders.hpp" -#include "ElementwiseFunction.hpp" -#include "Encoders.hpp" -#include "Profiling.hpp" -#include "RefWorkloadUtils.hpp" -#include "StringMapping.hpp" -#include <ResolveType.hpp> -#include <vector> - -namespace armnn -{ - -template <typename Functor, typename ParentDescriptor, typename armnn::StringMapping::Id DebugString> -RefElementwiseWorkload<Functor, ParentDescriptor, DebugString>::RefElementwiseWorkload( - const ParentDescriptor& desc, - const WorkloadInfo& info) - : BaseWorkload<ParentDescriptor>(desc, info) -{ -} - -template <typename Functor, typename ParentDescriptor, typename armnn::StringMapping::Id DebugString> -void RefElementwiseWorkload<Functor, ParentDescriptor, DebugString>::PostAllocationConfigure() -{ - const TensorInfo& inputInfo0 = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& inputInfo1 = GetTensorInfo(m_Data.m_Inputs[1]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - m_Input0 = MakeDecoder<InType>(inputInfo0); - m_Input1 = MakeDecoder<InType>(inputInfo1); - m_Output = MakeEncoder<OutType>(outputInfo); -} - -template <typename Functor, typename ParentDescriptor, typename armnn::StringMapping::Id DebugString> -void RefElementwiseWorkload<Functor, ParentDescriptor, DebugString>::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, StringMapping::Instance().Get(DebugString)); - const TensorInfo& inputInfo0 = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& inputInfo1 = GetTensorInfo(m_Data.m_Inputs[1]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - const TensorShape& inShape0 = inputInfo0.GetShape(); - const TensorShape& inShape1 = inputInfo1.GetShape(); - const TensorShape& outShape = outputInfo.GetShape(); - - m_Input0->Reset(m_Data.m_Inputs[0]->Map()); - m_Input1->Reset(m_Data.m_Inputs[1]->Map()); - m_Output->Reset(m_Data.m_Outputs[0]->Map()); - - ElementwiseBinaryFunction<Functor>(inShape0, - inShape1, - outShape, - *m_Input0, - *m_Input1, - *m_Output); -} - -} //namespace armnn - -template class armnn::RefElementwiseWorkload<std::plus<float>, - armnn::AdditionQueueDescriptor, - armnn::StringMapping::RefAdditionWorkload_Execute>; - -template class armnn::RefElementwiseWorkload<std::minus<float>, - armnn::SubtractionQueueDescriptor, - armnn::StringMapping::RefSubtractionWorkload_Execute>; - -template class armnn::RefElementwiseWorkload<std::multiplies<float>, - armnn::MultiplicationQueueDescriptor, - armnn::StringMapping::RefMultiplicationWorkload_Execute>; - -template class armnn::RefElementwiseWorkload<std::divides<float>, - armnn::DivisionQueueDescriptor, - armnn::StringMapping::RefDivisionWorkload_Execute>; - -template class armnn::RefElementwiseWorkload<armnn::maximum<float>, - armnn::MaximumQueueDescriptor, - armnn::StringMapping::RefMaximumWorkload_Execute>; - -template class armnn::RefElementwiseWorkload<armnn::minimum<float>, - armnn::MinimumQueueDescriptor, - armnn::StringMapping::RefMinimumWorkload_Execute>; diff --git a/src/backends/reference/workloads/RefElementwiseWorkload.hpp b/src/backends/reference/workloads/RefElementwiseWorkload.hpp deleted file mode 100644 index 264ddce2de..0000000000 --- a/src/backends/reference/workloads/RefElementwiseWorkload.hpp +++ /dev/null @@ -1,68 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Types.hpp> -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> -#include "BaseIterator.hpp" -#include "ElementwiseFunction.hpp" -#include "Maximum.hpp" -#include "Minimum.hpp" -#include "StringMapping.hpp" - -namespace armnn -{ - -template <typename Functor, typename ParentDescriptor, typename armnn::StringMapping::Id DebugString> -class RefElementwiseWorkload : public BaseWorkload<ParentDescriptor> -{ -public: - using InType = typename ElementwiseBinaryFunction<Functor>::InType; - using OutType = typename ElementwiseBinaryFunction<Functor>::OutType; - using BaseWorkload<ParentDescriptor>::m_Data; - - RefElementwiseWorkload(const ParentDescriptor& descriptor, const WorkloadInfo& info); - void PostAllocationConfigure() override; - void Execute() const override; - -private: - std::unique_ptr<Decoder<InType>> m_Input0; - std::unique_ptr<Decoder<InType>> m_Input1; - std::unique_ptr<Encoder<OutType>> m_Output; -}; - -using RefAdditionWorkload = - RefElementwiseWorkload<std::plus<float>, - AdditionQueueDescriptor, - StringMapping::RefAdditionWorkload_Execute>; - -using RefSubtractionWorkload = - RefElementwiseWorkload<std::minus<float>, - SubtractionQueueDescriptor, - StringMapping::RefSubtractionWorkload_Execute>; - -using RefMultiplicationWorkload = - RefElementwiseWorkload<std::multiplies<float>, - MultiplicationQueueDescriptor, - StringMapping::RefMultiplicationWorkload_Execute>; - -using RefDivisionWorkload = - RefElementwiseWorkload<std::divides<float>, - DivisionQueueDescriptor, - StringMapping::RefDivisionWorkload_Execute>; - -using RefMaximumWorkload = - RefElementwiseWorkload<armnn::maximum<float>, - MaximumQueueDescriptor, - StringMapping::RefMaximumWorkload_Execute>; - -using RefMinimumWorkload = - RefElementwiseWorkload<armnn::minimum<float>, - MinimumQueueDescriptor, - StringMapping::RefMinimumWorkload_Execute>; - -} // armnn diff --git a/src/backends/reference/workloads/RefFakeQuantizationFloat32Workload.cpp b/src/backends/reference/workloads/RefFakeQuantizationFloat32Workload.cpp deleted file mode 100644 index 3e16f60b11..0000000000 --- a/src/backends/reference/workloads/RefFakeQuantizationFloat32Workload.cpp +++ /dev/null @@ -1,42 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefFakeQuantizationFloat32Workload.hpp" - -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -#include <boost/numeric/conversion/cast.hpp> - -namespace armnn -{ - -void FakeQuantization(const float* inputData, float* outputData, uint32_t numElements, float min, float max) -{ - float scale = (max - min) / 255.f; - int32_t offset = boost::numeric_cast<int32_t>((-min * 255.f) / (max - min)); - - for (uint32_t i = 0; i < numElements; i++) - { - outputData[i] = static_cast<float>(armnn::Quantize<uint8_t>(inputData[i], scale, offset)); - } - -} - -void RefFakeQuantizationFloat32Workload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefFakeQuantizationFloat32Workload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - - const float* inputData = GetInputTensorDataFloat(0, m_Data); - float* outputData = GetOutputTensorDataFloat(0, m_Data); - FakeQuantization(inputData, outputData, inputInfo.GetNumElements(), - m_Data.m_Parameters.m_Min, - m_Data.m_Parameters.m_Max); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefFakeQuantizationFloat32Workload.hpp b/src/backends/reference/workloads/RefFakeQuantizationFloat32Workload.hpp deleted file mode 100644 index 62fb8e88b7..0000000000 --- a/src/backends/reference/workloads/RefFakeQuantizationFloat32Workload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefFakeQuantizationFloat32Workload : public Float32Workload<FakeQuantizationQueueDescriptor> -{ -public: - using Float32Workload<FakeQuantizationQueueDescriptor>::Float32Workload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefFloorWorkload.cpp b/src/backends/reference/workloads/RefFloorWorkload.cpp deleted file mode 100644 index d96b18b530..0000000000 --- a/src/backends/reference/workloads/RefFloorWorkload.cpp +++ /dev/null @@ -1,38 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefFloorWorkload.hpp" - -#include "Decoders.hpp" -#include "Encoders.hpp" -#include "RefWorkloadUtils.hpp" -#include "Profiling.hpp" - -namespace armnn -{ - -void RefFloorWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefFloorFloat32Workload_Execute"); - - const TensorInfo &inputTensorInfo = GetTensorInfo(m_Data.m_Inputs[0]); - std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputTensorInfo, m_Data.m_Inputs[0]->Map()); - Decoder<float> &decoder = *decoderPtr; - - const TensorInfo &outputTensorInfo = GetTensorInfo(m_Data.m_Outputs[0]); - std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputTensorInfo, m_Data.m_Outputs[0]->Map()); - Encoder<float> &encoder = *encoderPtr; - - unsigned int numElements = GetTensorInfo(m_Data.m_Inputs[0]).GetNumElements(); - - for (unsigned int i = 0; i < numElements; ++i) - { - encoder.Set(floorf(decoder.Get())); - ++decoder; - ++encoder; - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefFloorWorkload.hpp b/src/backends/reference/workloads/RefFloorWorkload.hpp deleted file mode 100644 index 2dea3a4259..0000000000 --- a/src/backends/reference/workloads/RefFloorWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefFloorWorkload : public BaseWorkload<FloorQueueDescriptor> -{ -public: - using BaseWorkload<FloorQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefFullyConnectedWorkload.cpp b/src/backends/reference/workloads/RefFullyConnectedWorkload.cpp deleted file mode 100644 index ac82db90e5..0000000000 --- a/src/backends/reference/workloads/RefFullyConnectedWorkload.cpp +++ /dev/null @@ -1,68 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefFullyConnectedWorkload.hpp" - -#include "FullyConnected.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -namespace armnn -{ -RefFullyConnectedWorkload::RefFullyConnectedWorkload( - const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info) - : BaseWorkload<FullyConnectedQueueDescriptor>(descriptor, info), - m_Weight(std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Weight))) -{ - const TensorInfo& rWeightInfo = m_Weight->GetTensorInfo(); - m_WeightShape = rWeightInfo.GetShape(); - m_WeightDecoder = MakeDecoder<float>(rWeightInfo, m_Weight->Map(true)); - - if (descriptor.m_Parameters.m_BiasEnabled) - { - m_Bias = std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Bias)); - const TensorInfo& biasInfo = m_Bias->GetTensorInfo(); - m_BiasDecoder = MakeDecoder<float>(biasInfo, m_Bias->Map(true)); - } -} - -void RefFullyConnectedWorkload::PostAllocationConfigure() -{ - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - BOOST_ASSERT(inputInfo.GetNumDimensions() > 1); - m_InputShape = inputInfo.GetShape(); - m_InputDecoder = MakeDecoder<float>(inputInfo); - - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - m_OutputShape = outputInfo.GetShape(); - m_OutputEncoder = MakeEncoder<float>(outputInfo); - - m_NumActivations = 1; // Total number of activations in the input. - for (unsigned int i = 1; i < inputInfo.GetNumDimensions(); i++) - { - m_NumActivations *= inputInfo.GetShape()[i]; - } -} - -void RefFullyConnectedWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefFullyConnectedWorkload_Execute"); - - m_InputDecoder->Reset(m_Data.m_Inputs[0]->Map()); - m_OutputEncoder->Reset(m_Data.m_Outputs[0]->Map()); - - FullyConnected(m_InputShape, - *m_InputDecoder, - m_OutputShape, - *m_OutputEncoder, - *m_WeightDecoder, - *m_BiasDecoder, - m_Data.m_Parameters.m_BiasEnabled, - m_NumActivations, - m_Data.m_Parameters.m_TransposeWeightMatrix); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefFullyConnectedWorkload.hpp b/src/backends/reference/workloads/RefFullyConnectedWorkload.hpp deleted file mode 100644 index d4a63d23ae..0000000000 --- a/src/backends/reference/workloads/RefFullyConnectedWorkload.hpp +++ /dev/null @@ -1,43 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - - -namespace armnn -{ - -class RefFullyConnectedWorkload : public BaseWorkload<FullyConnectedQueueDescriptor> -{ -public: - explicit RefFullyConnectedWorkload(const FullyConnectedQueueDescriptor& descriptor, - const WorkloadInfo& info); - - void PostAllocationConfigure() override; - - virtual void Execute() const override; - -private: - std::unique_ptr<ScopedCpuTensorHandle> m_Weight; - std::unique_ptr<ScopedCpuTensorHandle> m_Bias; - - std::unique_ptr<Decoder<float>> m_InputDecoder; - std::unique_ptr<Encoder<float>> m_OutputEncoder; - std::unique_ptr<Decoder<float>> m_WeightDecoder; - std::unique_ptr<Decoder<float>> m_BiasDecoder; - - TensorShape m_InputShape; - TensorShape m_OutputShape; - TensorShape m_WeightShape; - unsigned int m_NumActivations; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefGatherWorkload.cpp b/src/backends/reference/workloads/RefGatherWorkload.cpp deleted file mode 100644 index 8edf14c8f8..0000000000 --- a/src/backends/reference/workloads/RefGatherWorkload.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefGatherWorkload.hpp" - -#include "Gather.hpp" -#include "Profiling.hpp" -#include "RefWorkloadUtils.hpp" -#include <ResolveType.hpp> - -namespace armnn -{ - -void RefGatherWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefGatherWorkload_Execute"); - - const TensorInfo& inputInfo0 = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& inputInfo1 = GetTensorInfo(m_Data.m_Inputs[1]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputInfo0, m_Data.m_Inputs[0]->Map()); - Decoder<float>& decoder = *decoderPtr; - - const int32_t* indicesData = GetInputTensorData<int32_t>(1, m_Data); - - std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - Encoder<float>& encoder = *encoderPtr; - - Gather(inputInfo0, inputInfo1, outputInfo, decoder, indicesData, encoder); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefGatherWorkload.hpp b/src/backends/reference/workloads/RefGatherWorkload.hpp deleted file mode 100644 index 30019a8d4d..0000000000 --- a/src/backends/reference/workloads/RefGatherWorkload.hpp +++ /dev/null @@ -1,26 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -#include <armnn/TypesUtils.hpp> -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -class RefGatherWorkload : public BaseWorkload<GatherQueueDescriptor> -{ -public: - using BaseWorkload<GatherQueueDescriptor>::BaseWorkload; - void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefInstanceNormalizationWorkload.cpp b/src/backends/reference/workloads/RefInstanceNormalizationWorkload.cpp deleted file mode 100644 index 875d11a00d..0000000000 --- a/src/backends/reference/workloads/RefInstanceNormalizationWorkload.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefInstanceNormalizationWorkload.hpp" - -#include "InstanceNorm.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -namespace armnn -{ - -RefInstanceNormalizationWorkload::RefInstanceNormalizationWorkload( - const InstanceNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload<InstanceNormalizationQueueDescriptor>(descriptor, info) {} - -void RefInstanceNormalizationWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefInstanceNormalizationWorkload_Execute"); - - std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(GetTensorInfo(m_Data.m_Inputs[0]), - m_Data.m_Inputs[0]->Map()); - std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(m_Data.m_Outputs[0]), - m_Data.m_Outputs[0]->Map()); - - InstanceNorm(m_Data, *inputDecoder, *outputEncoder); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefInstanceNormalizationWorkload.hpp b/src/backends/reference/workloads/RefInstanceNormalizationWorkload.hpp deleted file mode 100644 index 3d8a72c361..0000000000 --- a/src/backends/reference/workloads/RefInstanceNormalizationWorkload.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefInstanceNormalizationWorkload : public BaseWorkload<InstanceNormalizationQueueDescriptor> -{ -public: - explicit RefInstanceNormalizationWorkload(const InstanceNormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info); - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefL2NormalizationWorkload.cpp b/src/backends/reference/workloads/RefL2NormalizationWorkload.cpp deleted file mode 100644 index 6fec1abe6f..0000000000 --- a/src/backends/reference/workloads/RefL2NormalizationWorkload.cpp +++ /dev/null @@ -1,100 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefL2NormalizationWorkload.hpp" -#include "RefWorkloadUtils.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <Profiling.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <boost/numeric/conversion/cast.hpp> - -#include <cmath> - -using namespace armnnUtils; - -namespace armnn -{ -RefL2NormalizationWorkload::RefL2NormalizationWorkload( - const L2NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload<L2NormalizationQueueDescriptor>(descriptor, info) {} - -void RefL2NormalizationWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefL2NormalizationWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - auto inputDecoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - auto outputEncoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - DataLayoutIndexed dataLayout(m_Data.m_Parameters.m_DataLayout); - - const TensorShape& shape = inputInfo.GetShape(); - unsigned int paddedShapeArray[4]; - const int idxShift = 4 - boost::numeric_cast<int>(shape.GetNumDimensions()); - - const unsigned int batches = (idxShift == 0) ? shape[0] : 1; - paddedShapeArray[0] = batches; - - const int channelsIdx = boost::numeric_cast<int>(dataLayout.GetChannelsIndex()); - const unsigned int channels = (channelsIdx - idxShift >= 0) - ? shape[boost::numeric_cast<unsigned int>(channelsIdx - idxShift)] - : 1; - paddedShapeArray[channelsIdx] = channels; - - const int heightIdx = boost::numeric_cast<int>(dataLayout.GetHeightIndex()); - const unsigned int height = (heightIdx - idxShift >= 0) - ? shape[boost::numeric_cast<unsigned int>(heightIdx - idxShift)] - : 1; - paddedShapeArray[heightIdx] = height; - - const int widthIdx = boost::numeric_cast<int>(dataLayout.GetWidthIndex()); - const unsigned int width = (widthIdx - idxShift >= 0) - ? shape[boost::numeric_cast<unsigned int>(widthIdx - idxShift)] - : 1; - paddedShapeArray[widthIdx] = width; - - const TensorShape& paddedShape = TensorShape(4, paddedShapeArray); - - for (unsigned int n = 0; n < batches; ++n) - { - for (unsigned int c = 0; c < channels; ++c) - { - for (unsigned int h = 0; h < height; ++h) - { - for (unsigned int w = 0; w < width; ++w) - { - float reduction = 0.0; - for (unsigned int d = 0; d < channels; ++d) - { - unsigned int inputIndex = dataLayout.GetIndex(paddedShape, n, d, h, w); - - (*inputDecoder)[inputIndex]; - const float value = inputDecoder->Get(); - reduction += value * value; - } - - unsigned int index = dataLayout.GetIndex(paddedShape, n, c, h, w); - - float maximum = reduction < m_Data.m_Parameters.m_Eps ? m_Data.m_Parameters.m_Eps : reduction; - - const float scale = 1.0f / sqrtf(maximum); - - (*inputDecoder)[index]; - (*outputEncoder)[index]; - outputEncoder->Set(inputDecoder->Get() * scale); - } - } - } - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefL2NormalizationWorkload.hpp b/src/backends/reference/workloads/RefL2NormalizationWorkload.hpp deleted file mode 100644 index 4beedc9992..0000000000 --- a/src/backends/reference/workloads/RefL2NormalizationWorkload.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefL2NormalizationWorkload : public BaseWorkload<L2NormalizationQueueDescriptor> -{ -public: - explicit RefL2NormalizationWorkload(const L2NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info); - - void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefLogSoftmaxWorkload.cpp b/src/backends/reference/workloads/RefLogSoftmaxWorkload.cpp deleted file mode 100644 index a987e79dda..0000000000 --- a/src/backends/reference/workloads/RefLogSoftmaxWorkload.cpp +++ /dev/null @@ -1,36 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefLogSoftmaxWorkload.hpp" - -#include "Decoders.hpp" -#include "Encoders.hpp" -#include "LogSoftmax.hpp" -#include "RefWorkloadUtils.hpp" - -#include <Profiling.hpp> - -#include <boost/assert.hpp> - -namespace armnn -{ - -void RefLogSoftmaxWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefLogSoftmaxWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - std::unique_ptr<Decoder<float>> decoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - std::unique_ptr<Encoder<float>> encoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - BOOST_ASSERT(decoder != nullptr); - BOOST_ASSERT(encoder != nullptr); - - LogSoftmax(*decoder, *encoder, inputInfo, m_Data.m_Parameters); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefLogSoftmaxWorkload.hpp b/src/backends/reference/workloads/RefLogSoftmaxWorkload.hpp deleted file mode 100644 index f5048d90b3..0000000000 --- a/src/backends/reference/workloads/RefLogSoftmaxWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefLogSoftmaxWorkload : public BaseWorkload<LogSoftmaxQueueDescriptor> -{ -public: - using BaseWorkload<LogSoftmaxQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefLstmWorkload.cpp b/src/backends/reference/workloads/RefLstmWorkload.cpp deleted file mode 100644 index 70b3443d88..0000000000 --- a/src/backends/reference/workloads/RefLstmWorkload.cpp +++ /dev/null @@ -1,383 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefLstmWorkload.hpp" -#include "Activation.hpp" -#include "Encoders.hpp" -#include "Decoders.hpp" -#include "LstmUtils.hpp" -#include "RefWorkloadUtils.hpp" - -namespace armnn -{ - -RefLstmWorkload::RefLstmWorkload(const LstmQueueDescriptor &descriptor, const WorkloadInfo &info) - : BaseWorkload<LstmQueueDescriptor>(descriptor, info) - , m_InputToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToInputWeights)) - , m_InputToForgetWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToForgetWeights)) - , m_InputToCellWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToCellWeights)) - , m_InputToOutputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToOutputWeights)) - , m_RecurrentToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_RecurrentToInputWeights)) - , m_RecurrentToForgetWeightsTensor(AssignScopedCpuTensorHandle(descriptor.m_RecurrentToForgetWeights)) - , m_RecurrentToCellWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_RecurrentToCellWeights)) - , m_RecurrentToOutputWeightsTensor(AssignScopedCpuTensorHandle(descriptor.m_RecurrentToOutputWeights)) - , m_CellToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToInputWeights)) - , m_CellToForgetWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToForgetWeights)) - , m_CellToOutputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToOutputWeights)) - , m_InputGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_InputGateBias)) - , m_ForgetGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_ForgetGateBias)) - , m_CellBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_CellBias)) - , m_OutputGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_OutputGateBias)) - , m_ProjectionWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_ProjectionWeights)) - , m_ProjectionBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_ProjectionBias)) - , m_InputLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_InputLayerNormWeights)) - , m_ForgetLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_ForgetLayerNormWeights)) - , m_CellLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_CellLayerNormWeights)) - , m_OutputLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_OutputLayerNormWeights)) -{} - -void RefLstmWorkload::Execute() const -{ - // This is a porting of the LSTM::Eval() method in the Android code base - // Refer to: android/frameworks/ml/nn/common/operations/LSTM.cpp - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - const TensorShape& inputShape = inputInfo.GetShape(); - const DataType& outputType = outputInfo.GetDataType(); - - std::unique_ptr<Encoder<float>> outputStateOut = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[1]->Map()); - std::unique_ptr<Encoder<float>> cellStateOut = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[2]->Map()); - std::unique_ptr<Encoder<float>> output = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[3]->Map()); - - std::unique_ptr<Decoder<float>> cellStateOutDecoder = MakeDecoder<float>(outputInfo, m_Data.m_Outputs[2]->Map()); - std::unique_ptr<Decoder<float>> outputDecoder = MakeDecoder<float>(outputInfo, m_Data.m_Outputs[3]->Map()); - - std::unique_ptr<Decoder<float>> inputData = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - std::unique_ptr<Decoder<float>> outputStateIn = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[1]->Map()); - std::unique_ptr<Decoder<float>> cellStateIn = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[2]->Map()); - - const uint32_t nBatch = inputShape[0]; - const uint32_t nInput = inputShape[1]; - - const uint32_t nCell = m_InputToOutputWeightsTensor->GetShape()[0]; - const uint32_t nOutput = m_RecurrentToOutputWeightsTensor->GetShape()[1]; - - const bool useCifg = m_Data.m_Parameters.m_CifgEnabled; - const bool usePeephole = m_Data.m_Parameters.m_PeepholeEnabled; - const bool useLayerNorm = m_Data.m_Parameters.m_LayerNormEnabled; - - // Index the scratch buffers pointers to the global scratch buffer. - std::unique_ptr<Encoder<float>> inputGateScratch = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - std::unique_ptr<Encoder<float>> cellScratch = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - std::unique_ptr<Encoder<float>> forgetGateScratch = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - std::unique_ptr<Encoder<float>> outputGateScratch = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - std::unique_ptr<Decoder<float>> inputGateScratchDecoder = - MakeDecoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - std::unique_ptr<Decoder<float>> cellScratchDecoder = - MakeDecoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - std::unique_ptr<Decoder<float>> forgetGateScratchDecoder = - MakeDecoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - std::unique_ptr<Decoder<float>> outputGateScratchDecoder = - MakeDecoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - if (useCifg) - { - *cellScratch += (0 * nCell * nBatch); - *forgetGateScratch += (1 * nCell * nBatch); - *outputGateScratch += (2 * nCell * nBatch); - - *cellScratchDecoder += (0 * nCell * nBatch); - *forgetGateScratchDecoder += (1 * nCell * nBatch); - *outputGateScratchDecoder += (2 * nCell * nBatch); - } - else - { - *inputGateScratch += (0 * nCell * nBatch); - *cellScratch += (1 * nCell * nBatch); - *forgetGateScratch += (2 * nCell * nBatch); - *outputGateScratch += (3 * nCell * nBatch); - - *inputGateScratchDecoder += (0 * nCell * nBatch); - *cellScratchDecoder += (1 * nCell * nBatch); - *forgetGateScratchDecoder += (2 * nCell * nBatch); - *outputGateScratchDecoder += (3 * nCell * nBatch); - } - - std::unique_ptr<Decoder<float>> inputToInputWeightsTensor; - std::unique_ptr<Decoder<float>> inputToForgetWeightsTensor = MakeDecoder<float>( - m_InputToForgetWeightsTensor->GetTensorInfo(), m_InputToForgetWeightsTensor->GetTensor<void>()); - std::unique_ptr<Decoder<float>> inputToCellWeightsTensor = MakeDecoder<float>( - m_InputToCellWeightsTensor->GetTensorInfo(), m_InputToCellWeightsTensor->GetTensor<void>()); - std::unique_ptr<Decoder<float>> inputToOutputWeightsTensor = MakeDecoder<float>( - m_InputToOutputWeightsTensor->GetTensorInfo(), m_InputToOutputWeightsTensor->GetTensor<void>()); - - std::unique_ptr<Decoder<float>> recurrentToInputWeightsTensor; - std::unique_ptr<Decoder<float>> recurrentToForgetWeightsTensor = MakeDecoder<float>( - m_RecurrentToForgetWeightsTensor->GetTensorInfo(), m_RecurrentToForgetWeightsTensor->GetTensor<void>()); - std::unique_ptr<Decoder<float>> recurrentToCellWeightsTensor = MakeDecoder<float>( - m_RecurrentToCellWeightsTensor->GetTensorInfo(), m_RecurrentToCellWeightsTensor->GetTensor<void>()); - std::unique_ptr<Decoder<float>> recurrentToOutputWeightsTensor = MakeDecoder<float>( - m_RecurrentToOutputWeightsTensor->GetTensorInfo(), m_RecurrentToOutputWeightsTensor->GetTensor<void>()); - - std::unique_ptr<Decoder<float>> inputGateBiasTensor; - std::unique_ptr<Decoder<float>> forgetGateBiasTensor = MakeDecoder<float>( - m_ForgetGateBiasTensor->GetTensorInfo(), m_ForgetGateBiasTensor->GetTensor<void>()); - std::unique_ptr<Decoder<float>> cellBiasTensor = MakeDecoder<float>( - m_CellBiasTensor->GetTensorInfo(), m_CellBiasTensor->GetTensor<void>()); - std::unique_ptr<Decoder<float>> outputGateBiasTensor = MakeDecoder<float>( - m_OutputGateBiasTensor->GetTensorInfo(), m_OutputGateBiasTensor->GetTensor<void>()); - - std::unique_ptr<Decoder<float>> cellToInputWeightsTensor; - std::unique_ptr<Decoder<float>> cellToForgetWeightsTensor; - std::unique_ptr<Decoder<float>> cellToOutputWeightsTensor; - - std::unique_ptr<Decoder<float>> projectionWeightsTensor; - std::unique_ptr<Decoder<float>> projectionBiasTensor; - - std::unique_ptr<Decoder<float>> inputLayerNormWeights; - std::unique_ptr<Decoder<float>> forgetLayerNormWeights; - std::unique_ptr<Decoder<float>> cellLayerNormWeights; - std::unique_ptr<Decoder<float>> outputLayerNormWeights; - - if (useLayerNorm) - { - if (!useCifg) - { - inputLayerNormWeights = MakeDecoder<float>( - m_InputLayerNormWeights->GetTensorInfo(), m_InputLayerNormWeights->GetTensor<void>()); - } - forgetLayerNormWeights = MakeDecoder<float>( - m_ForgetLayerNormWeights->GetTensorInfo(), m_ForgetLayerNormWeights->GetTensor<void>()); - cellLayerNormWeights = MakeDecoder<float>( - m_CellLayerNormWeights->GetTensorInfo(), m_CellLayerNormWeights->GetTensor<void>()); - outputLayerNormWeights = MakeDecoder<float>( - m_OutputLayerNormWeights->GetTensorInfo(), m_OutputLayerNormWeights->GetTensor<void>()); - } - - if (!useCifg) - { - inputToInputWeightsTensor = MakeDecoder<float>( - m_InputToInputWeightsTensor->GetTensorInfo(), m_InputToInputWeightsTensor->GetTensor<void>()); - inputGateBiasTensor = MakeDecoder<float>( - m_InputGateBiasTensor->GetTensorInfo(), m_InputGateBiasTensor->GetTensor<void>()); - recurrentToInputWeightsTensor = MakeDecoder<float>( - m_RecurrentToInputWeightsTensor->GetTensorInfo(), m_RecurrentToInputWeightsTensor->GetTensor<void>()); - } - - if (usePeephole) - { - cellToForgetWeightsTensor = MakeDecoder<float>( - m_CellToForgetWeightsTensor->GetTensorInfo(), m_CellToForgetWeightsTensor->GetTensor<void>()); - cellToOutputWeightsTensor = MakeDecoder<float>( - m_CellToOutputWeightsTensor->GetTensorInfo(), m_CellToOutputWeightsTensor->GetTensor<void>()); - } - - if (!useCifg && usePeephole) - { - cellToInputWeightsTensor = MakeDecoder<float>( - m_CellToInputWeightsTensor->GetTensorInfo(), m_CellToInputWeightsTensor->GetTensor<void>()); - } - - if (m_Data.m_Parameters.m_ProjectionEnabled) - { - projectionWeightsTensor = MakeDecoder<float>( - m_ProjectionWeightsTensor->GetTensorInfo(), m_ProjectionWeightsTensor->GetTensor<void>()); - if (m_ProjectionBiasTensor) - { - projectionBiasTensor = MakeDecoder<float>( - m_ProjectionBiasTensor->GetTensorInfo(), m_ProjectionBiasTensor->GetTensor<void>()); - } - } - - if (!useLayerNorm) - { - // Initialize scratch buffers with bias. - if (!useCifg) - { - VectorBatchVectorAssign(*inputGateBiasTensor, - nCell, nBatch, *inputGateScratch); - } - VectorBatchVectorAssign(*forgetGateBiasTensor, - nCell, nBatch, *forgetGateScratch); - VectorBatchVectorAssign(*cellBiasTensor, - nCell, nBatch, *cellScratch); - VectorBatchVectorAssign(*outputGateBiasTensor, - nCell, nBatch, *outputGateScratch); - } - else - { - // Initialize scratch buffers with zeroes. - if (!useCifg) - { - ZeroVector(*inputGateScratch, nCell * nBatch); - } - ZeroVector(*forgetGateScratch, nCell * nBatch); - ZeroVector(*cellScratch , nCell * nBatch); - ZeroVector(*outputGateScratch, nCell * nBatch); - } - - // For each batch and cell: compute input_weight * input. - if (!useCifg) - { - MatrixBatchVectorMultiplyAccumulate(*inputToInputWeightsTensor, - nCell, nInput, *inputData, nBatch, *inputGateScratch); - } - MatrixBatchVectorMultiplyAccumulate(*inputToForgetWeightsTensor, - nCell, nInput, *inputData, nBatch, *forgetGateScratch); - MatrixBatchVectorMultiplyAccumulate(*inputToCellWeightsTensor, - nCell, nInput, *inputData, nBatch, *cellScratch); - MatrixBatchVectorMultiplyAccumulate(*inputToOutputWeightsTensor, - nCell, nInput, *inputData, nBatch, *outputGateScratch); - - // For each batch and cell: compute recurrent_weight * output_state. - if (!useCifg) - { - MatrixBatchVectorMultiplyAccumulate(*recurrentToInputWeightsTensor, - nCell, nOutput, *outputStateIn, nBatch, *inputGateScratch); - } - MatrixBatchVectorMultiplyAccumulate(*recurrentToForgetWeightsTensor, - nCell, nOutput, *outputStateIn, nBatch, *forgetGateScratch); - MatrixBatchVectorMultiplyAccumulate(*recurrentToCellWeightsTensor, - nCell, nOutput, *outputStateIn, nBatch, *cellScratch); - MatrixBatchVectorMultiplyAccumulate(*recurrentToOutputWeightsTensor, - nCell, nOutput, *outputStateIn, nBatch, *outputGateScratch); - - // For each batch and cell: update input gate. - if (!useCifg) - { - if (usePeephole) - { - VectorBatchVectorCwiseProductAccumulate(*cellToInputWeightsTensor, - nCell, *cellStateIn, nBatch, *inputGateScratch); - } - if (useLayerNorm) - { - MeanStddevNormalization(*inputGateScratchDecoder, - *inputGateScratch, nCell, nBatch, m_LayerNormEpsilon); - VectorBatchVectorCwiseProduct(*inputLayerNormWeights, - nCell, *inputGateScratchDecoder, nBatch, *inputGateScratch); - VectorBatchVectorAdd(*inputGateBiasTensor, - nCell, *inputGateScratchDecoder, nBatch, *inputGateScratch); - } - Activation(*inputGateScratchDecoder, *inputGateScratch, - TensorInfo({nCell, nBatch}, outputType), - ActivationFunction::Sigmoid, 0, 0); - } - - // For each batch and cell: update forget gate. - if (usePeephole) - { - VectorBatchVectorCwiseProductAccumulate(*cellToForgetWeightsTensor, nCell, - *cellStateIn, nBatch, *forgetGateScratch); - } - if (useLayerNorm) - { - MeanStddevNormalization(*forgetGateScratchDecoder, - *forgetGateScratch, nCell, nBatch, m_LayerNormEpsilon); - VectorBatchVectorCwiseProduct(*forgetLayerNormWeights, - nCell, *forgetGateScratchDecoder, nBatch, *forgetGateScratch); - VectorBatchVectorAdd(*forgetGateBiasTensor, - nCell, *forgetGateScratchDecoder, nBatch, *forgetGateScratch); - } - Activation(*forgetGateScratchDecoder, *forgetGateScratch, - TensorInfo({nCell, nBatch}, outputType), - ActivationFunction::Sigmoid, 0, 0); - - // For each batch and cell: update the cell. - if (useLayerNorm) - { - MeanStddevNormalization(*cellScratchDecoder, - *cellScratch, nCell, nBatch, m_LayerNormEpsilon); - VectorBatchVectorCwiseProduct(*cellLayerNormWeights, - nCell, *cellScratchDecoder, nBatch, *cellScratch); - VectorBatchVectorAdd(*cellBiasTensor, - nCell, *cellScratchDecoder, nBatch, *cellScratch); - } - - VectorVectorCwiseProduct(*forgetGateScratchDecoder, *cellStateIn, nBatch * nCell, *cellStateOut); - - ActivationFunction armnnActivationFunc = ActivationFunction::Sigmoid; - float a = 0; - float b = 0; - SetActivationParameters(m_Data.m_Parameters.m_ActivationFunc, armnnActivationFunc, a, b); - - if (m_Data.m_Parameters.m_ActivationFunc > 0) - { - Activation(*cellScratchDecoder, *cellScratch, - TensorInfo({nCell, nBatch}, outputType), - armnnActivationFunc, a, b); - } - if (useCifg) - { - Sub1Vector(*forgetGateScratchDecoder, nBatch * nCell, *forgetGateScratch); - VectorVectorCwiseProductAccumulate( - *cellScratchDecoder, *forgetGateScratchDecoder, nBatch * nCell, *cellStateOut); - } - else - { - VectorVectorCwiseProductAccumulate( - *cellScratchDecoder, *inputGateScratchDecoder, nBatch * nCell, *cellStateOut); - } - if (m_Data.m_Parameters.m_ClippingThresCell > 0.0) - { - ClipVector(*cellStateOutDecoder, nBatch * nCell, m_Data.m_Parameters.m_ClippingThresCell, *cellStateOut); - } - - // For each batch and cell: update the output gate. - if (usePeephole) - { - VectorBatchVectorCwiseProductAccumulate(*cellToOutputWeightsTensor, - nCell, *cellStateOutDecoder, nBatch, *outputGateScratch); - } - if (useLayerNorm) - { - MeanStddevNormalization(*outputGateScratchDecoder, - *outputGateScratch, nCell, nBatch, m_LayerNormEpsilon); - VectorBatchVectorCwiseProduct(*outputLayerNormWeights, - nCell, *outputGateScratchDecoder, nBatch, *outputGateScratch); - VectorBatchVectorAdd(*outputGateBiasTensor, - nCell, *outputGateScratchDecoder, nBatch, *outputGateScratch); - } - Activation(*outputGateScratchDecoder, *outputGateScratch, - TensorInfo({nCell, nBatch}, outputType), - ActivationFunction::Sigmoid, 0, 0); - - if (m_Data.m_Parameters.m_ActivationFunc > 0) - { - Activation(*cellStateOutDecoder, *cellScratch, - TensorInfo({nCell, nBatch}, outputType), - armnnActivationFunc, a, b); - } - - VectorVectorCwiseProduct(*outputGateScratchDecoder, *cellScratchDecoder, nBatch * nCell, *outputGateScratch); - - // For each batch: update the projection and output_state. - if (m_Data.m_Parameters.m_ProjectionEnabled) - { - if (m_ProjectionBiasTensor) - { - VectorBatchVectorAssign(*projectionBiasTensor, - nOutput, nBatch, *output); - } - MatrixBatchVectorMultiplyAccumulate(*projectionWeightsTensor, - nOutput, nCell, *outputGateScratchDecoder, nBatch, *output); - - if (m_Data.m_Parameters.m_ClippingThresProj > 0.0) - { - ClipVector(*outputDecoder, nBatch * nOutput, m_Data.m_Parameters.m_ClippingThresProj, *output); - } - } - else - { - CopyVector(*outputGateScratchDecoder, nBatch * nOutput, *output); - } - - CopyVector(*outputDecoder, nBatch * nOutput, *outputStateOut); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefLstmWorkload.hpp b/src/backends/reference/workloads/RefLstmWorkload.hpp deleted file mode 100644 index ce5a775269..0000000000 --- a/src/backends/reference/workloads/RefLstmWorkload.hpp +++ /dev/null @@ -1,49 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/TypesUtils.hpp> - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefLstmWorkload : public BaseWorkload<LstmQueueDescriptor> -{ -public: - explicit RefLstmWorkload(const LstmQueueDescriptor& descriptor, const WorkloadInfo& info); - - virtual void Execute() const override; - -private: - std::unique_ptr<ScopedCpuTensorHandle> m_InputToInputWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_InputToForgetWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_InputToCellWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_InputToOutputWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToInputWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToForgetWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToCellWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToOutputWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_CellToInputWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_CellToForgetWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_CellToOutputWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_InputGateBiasTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_ForgetGateBiasTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_CellBiasTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_OutputGateBiasTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_ProjectionWeightsTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_ProjectionBiasTensor; - std::unique_ptr<ScopedCpuTensorHandle> m_InputLayerNormWeights; - std::unique_ptr<ScopedCpuTensorHandle> m_ForgetLayerNormWeights; - std::unique_ptr<ScopedCpuTensorHandle> m_CellLayerNormWeights; - std::unique_ptr<ScopedCpuTensorHandle> m_OutputLayerNormWeights; - - float m_LayerNormEpsilon = static_cast<float>(1e-8); -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefMeanWorkload.cpp b/src/backends/reference/workloads/RefMeanWorkload.cpp deleted file mode 100644 index 375ab395be..0000000000 --- a/src/backends/reference/workloads/RefMeanWorkload.cpp +++ /dev/null @@ -1,34 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefMeanWorkload.hpp" - -#include "Mean.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -#include <vector> - -namespace armnn -{ - -RefMeanWorkload::RefMeanWorkload(const MeanQueueDescriptor& descriptor, const WorkloadInfo& info) - :BaseWorkload<MeanQueueDescriptor>(descriptor, info) {} - -void RefMeanWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefMeanWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - auto inputDecoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - auto outputEncoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - Mean(inputInfo, outputInfo, m_Data.m_Parameters.m_Axis, *inputDecoder, *outputEncoder); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefMeanWorkload.hpp b/src/backends/reference/workloads/RefMeanWorkload.hpp deleted file mode 100644 index c673f940e0..0000000000 --- a/src/backends/reference/workloads/RefMeanWorkload.hpp +++ /dev/null @@ -1,24 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -class RefMeanWorkload : public BaseWorkload<MeanQueueDescriptor> -{ -public: - explicit RefMeanWorkload (const MeanQueueDescriptor& descriptor, const WorkloadInfo& info); - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefNormalizationWorkload.cpp b/src/backends/reference/workloads/RefNormalizationWorkload.cpp deleted file mode 100644 index 77497c4458..0000000000 --- a/src/backends/reference/workloads/RefNormalizationWorkload.cpp +++ /dev/null @@ -1,210 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefNormalizationWorkload.hpp" - -#include <armnn/Logging.hpp> -#include <armnn/Tensor.hpp> -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <Profiling.hpp> - -#include <boost/numeric/conversion/cast.hpp> - -#include "RefWorkloadUtils.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -using namespace armnn; -using namespace armnnUtils; - -namespace -{ - -// Helper function to compute "Within" normalization using Krichevsky 2012: Local Brightness Normalization. -void NormalizeWithinUingLbr(Decoder<float>& inputData, - Encoder<float>& outputData, - const TensorShape& tensorShape, - uint32_t norm_size, - float alpha, - float beta, - float kappa) -{ - const unsigned int batchSize = tensorShape[0]; - const unsigned int depth = tensorShape[1]; - const unsigned int rows = tensorShape[2]; - const unsigned int cols = tensorShape[3]; - - int radius = boost::numeric_cast<int>(norm_size / 2u); /* Strong Assumption on rounding Mode */ - - for (unsigned int n = 0; n < batchSize; n++) - { - for (unsigned int c = 0; c < depth; c++) - { - for (unsigned int h = 0; h < rows; h++) - { - for (unsigned int w = 0; w < cols; w++) - { - float accumulated_scale = 0.0; - for (int y = -radius; y <= radius; y++) - { - for (int x = -radius; x <= radius; x++) - { - int i = boost::numeric_cast<int>(w) + x; - int j = boost::numeric_cast<int>(h) + y; - - if ((i < 0) || (i >= boost::numeric_cast<int>(cols))) - { - continue; - } - - if ((j < 0) || (j >= boost::numeric_cast<int>(rows))) - { - continue; - } - - unsigned int inputIndex = n * cols * rows * depth + - c * cols * rows + - boost::numeric_cast<unsigned int>(j) * cols + - boost::numeric_cast<unsigned int>(i); - inputData[inputIndex]; - float inval = inputData.Get(); - - accumulated_scale += inval*inval; - } - } - - unsigned int index = n * cols * rows * depth + - c * cols * rows + - h * cols + - w; - inputData[index]; - outputData[index]; - outputData.Set(inputData.Get() / (powf((kappa + (accumulated_scale * alpha)), beta))); - } - } - } - } -} - -// Helper function to compute "Across" normalization using Krichevsky 2012: Local Brightness Normalization. -void NormalizeAcrossUingLbr(Decoder<float>& inputData, - Encoder<float>& outputData, - const TensorShape& tensorShape, - uint32_t norm_size, - float alpha, - float beta, - float kappa, - DataLayout dataLayout) -{ - DataLayoutIndexed dataLayoutIndexed(dataLayout); - - const unsigned int batchSize = tensorShape[0]; - const unsigned int depth = tensorShape[dataLayoutIndexed.GetChannelsIndex()]; - const unsigned int rows = tensorShape[dataLayoutIndexed.GetHeightIndex()]; - const unsigned int cols = tensorShape[dataLayoutIndexed.GetWidthIndex()]; - - int radius = boost::numeric_cast<int>(norm_size / 2u); /* Strong Assumption on rounding Mode */ - - for (unsigned int n = 0; n < batchSize; n++) - { - for (unsigned int c = 0; c < depth; c++) - { - for (unsigned int h = 0; h < rows; h++) - { - for (unsigned int w = 0; w < cols; w++) - { - float accumulated_scale = 0.0; - for (int z = -radius; z <= radius; z++) - { - int k = boost::numeric_cast<int>(c) + z; - - if ((k < 0) || (k >= boost::numeric_cast<int>(depth))) - { - continue; - } - - unsigned inputIndex = dataLayoutIndexed.GetIndex(tensorShape, - n, - boost::numeric_cast<unsigned int>(k), - h, - w); - - inputData[inputIndex]; - float inval = inputData.Get(); - - accumulated_scale += inval * inval; - } - - float scale = kappa + (accumulated_scale * alpha); - scale = powf(scale, -beta); - - unsigned index = dataLayoutIndexed.GetIndex(tensorShape, n, c, h, w); - - inputData[index]; - outputData[index]; - outputData.Set(scale * inputData.Get()); - } - } - } - } -} - -} // Anonymous namespace - -namespace armnn -{ - -RefNormalizationWorkload::RefNormalizationWorkload(const NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload(descriptor, info) -{} - -void RefNormalizationWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefNormalizationWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - - auto inputDecoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - auto outputEncoder = MakeEncoder<float>(inputInfo, m_Data.m_Outputs[0]->Map()); - - if (NormalizationAlgorithmMethod::LocalBrightness == m_Data.m_Parameters.m_NormMethodType) - { - if (NormalizationAlgorithmChannel::Within == m_Data.m_Parameters.m_NormChannelType) - { - NormalizeWithinUingLbr(*inputDecoder, - *outputEncoder, - inputInfo.GetShape(), - m_Data.m_Parameters.m_NormSize, - m_Data.m_Parameters.m_Alpha, - m_Data.m_Parameters.m_Beta, - m_Data.m_Parameters.m_K); - } - else if (NormalizationAlgorithmChannel::Across == m_Data.m_Parameters.m_NormChannelType) - { - NormalizeAcrossUingLbr(*inputDecoder, - *outputEncoder, - inputInfo.GetShape(), - m_Data.m_Parameters.m_NormSize, - m_Data.m_Parameters.m_Alpha, - m_Data.m_Parameters.m_Beta, - m_Data.m_Parameters.m_K, - m_Data.m_Parameters.m_DataLayout); - } - else - { - ARMNN_LOG(warning) << "Illegal NORMALIZATION mode in normalization_f32"; - return; - } - } - else - { - ARMNN_LOG(warning) << "Lcr method (Jarret 2009: Local Contrast Normalization) not supported yet."; - return; - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefNormalizationWorkload.hpp b/src/backends/reference/workloads/RefNormalizationWorkload.hpp deleted file mode 100644 index 6d33c8afb2..0000000000 --- a/src/backends/reference/workloads/RefNormalizationWorkload.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefNormalizationWorkload : public BaseWorkload<NormalizationQueueDescriptor> -{ -public: - explicit RefNormalizationWorkload(const NormalizationQueueDescriptor& descriptor, - const WorkloadInfo& info); - - virtual void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefPadWorkload.cpp b/src/backends/reference/workloads/RefPadWorkload.cpp deleted file mode 100644 index 356f6b1172..0000000000 --- a/src/backends/reference/workloads/RefPadWorkload.cpp +++ /dev/null @@ -1,41 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefPadWorkload.hpp" - -#include "Pad.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" - -#include <ResolveType.hpp> - -#include <vector> - -namespace armnn -{ - -template <armnn::DataType DataType> -void RefPadWorkload<DataType>::Execute() const -{ - using T = ResolveType<DataType>; - - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefPadWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - const T* inputData = GetInputTensorData<T>(0, m_Data); - T* outputData = GetOutputTensorData<T>(0, m_Data); - - Pad(inputInfo, outputInfo, m_Data.m_Parameters.m_PadList, inputData, outputData, m_Data.m_Parameters.m_PadValue); -} - -template class RefPadWorkload<DataType::Float32>; -template class RefPadWorkload<DataType::Float16>; -template class RefPadWorkload<DataType::QAsymmU8>; -template class RefPadWorkload<DataType::QSymmS16>; - -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefPadWorkload.hpp b/src/backends/reference/workloads/RefPadWorkload.hpp deleted file mode 100644 index 28fb55386e..0000000000 --- a/src/backends/reference/workloads/RefPadWorkload.hpp +++ /dev/null @@ -1,38 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -#include <armnn/TypesUtils.hpp> - -namespace armnn -{ - -template <armnn::DataType DataType> -class RefPadWorkload : public TypedWorkload<PadQueueDescriptor, DataType> -{ -public: - - static const std::string& GetName() - { - static const std::string name = std::string("RefPad") + GetDataTypeName(DataType) + "Workload"; - return name; - } - - using TypedWorkload<PadQueueDescriptor, DataType>::m_Data; - using TypedWorkload<PadQueueDescriptor, DataType>::TypedWorkload; - - void Execute() const override; -}; - -using RefPadFloat32Workload = RefPadWorkload<DataType::Float32>; -using RefPadFloat16Workload = RefPadWorkload<DataType::Float16>; -using RefPadQAsymm8Workload = RefPadWorkload<DataType::QAsymmU8>; -using RefPadQSymm16Workload = RefPadWorkload<DataType::QSymmS16>; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefPermuteWorkload.cpp b/src/backends/reference/workloads/RefPermuteWorkload.cpp deleted file mode 100644 index d0e1431ffd..0000000000 --- a/src/backends/reference/workloads/RefPermuteWorkload.cpp +++ /dev/null @@ -1,36 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefPermuteWorkload.hpp" -#include "RefWorkloadUtils.hpp" - -#include <armnnUtils/Permute.hpp> - -#include <ResolveType.hpp> - -namespace armnn -{ - -template <armnn::DataType DataType> -void RefPermuteWorkload<DataType>::Execute() const -{ - using T = ResolveType<DataType>; - - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, GetName() + "_Execute"); - - const ITensorHandle* src = m_Data.m_Inputs[0]; - ITensorHandle* dst = m_Data.m_Outputs[0]; - const PermutationVector& mappings = m_Data.m_Parameters.m_DimMappings; - - armnnUtils::Permute(GetTensorInfo(dst).GetShape(), mappings, - src->Map(), dst->Map(), sizeof(T)); -} - -template class RefPermuteWorkload<DataType::Float16>; -template class RefPermuteWorkload<DataType::Float32>; -template class RefPermuteWorkload<DataType::QAsymmU8>; -template class RefPermuteWorkload<DataType::QSymmS16>; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefPermuteWorkload.hpp b/src/backends/reference/workloads/RefPermuteWorkload.hpp deleted file mode 100644 index 00a33850aa..0000000000 --- a/src/backends/reference/workloads/RefPermuteWorkload.hpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> - -#include <armnn/TypesUtils.hpp> - -namespace armnn -{ - -template <armnn::DataType DataType> -class RefPermuteWorkload : public TypedWorkload<PermuteQueueDescriptor, DataType> -{ -public: - static const std::string& GetName() - { - static const std::string name = std::string("RefPermute") + GetDataTypeName(DataType) + "Workload"; - return name; - } - - using TypedWorkload<PermuteQueueDescriptor, DataType>::m_Data; - using TypedWorkload<PermuteQueueDescriptor, DataType>::TypedWorkload; - void Execute() const override; -}; - -using RefPermuteFloat16Workload = RefPermuteWorkload<DataType::Float16>; -using RefPermuteFloat32Workload = RefPermuteWorkload<DataType::Float32>; -using RefPermuteQAsymm8Workload = RefPermuteWorkload<DataType::QAsymmU8>; -using RefPermuteQSymm16Workload = RefPermuteWorkload<DataType::QSymmS16>; - -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefPooling2dWorkload.cpp b/src/backends/reference/workloads/RefPooling2dWorkload.cpp deleted file mode 100644 index becbae2934..0000000000 --- a/src/backends/reference/workloads/RefPooling2dWorkload.cpp +++ /dev/null @@ -1,32 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefPooling2dWorkload.hpp" - -#include "Pooling2d.hpp" -#include "RefWorkloadUtils.hpp" - -#include "Profiling.hpp" -#include "BaseIterator.hpp" - -namespace armnn -{ -void RefPooling2dWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefPooling2dWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - auto inputDecoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0] ->Map()); - auto outputEncoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - Pooling2d(*inputDecoder, - *outputEncoder, - inputInfo, - outputInfo, - m_Data.m_Parameters); -} -} //namespace armnn diff --git a/src/backends/reference/workloads/RefPooling2dWorkload.hpp b/src/backends/reference/workloads/RefPooling2dWorkload.hpp deleted file mode 100644 index 7c4f35afc0..0000000000 --- a/src/backends/reference/workloads/RefPooling2dWorkload.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ -class RefPooling2dWorkload : public BaseWorkload<Pooling2dQueueDescriptor> -{ -public: - using BaseWorkload<Pooling2dQueueDescriptor>::BaseWorkload; - - virtual void Execute() const override; -}; -} //namespace armnn diff --git a/src/backends/reference/workloads/RefPreluWorkload.cpp b/src/backends/reference/workloads/RefPreluWorkload.cpp deleted file mode 100644 index cdc0a63711..0000000000 --- a/src/backends/reference/workloads/RefPreluWorkload.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefPreluWorkload.hpp" - -#include "RefWorkloadUtils.hpp" -#include "PreluImpl.hpp" - -#include <Profiling.hpp> - -namespace armnn -{ - -RefPreluWorkload::RefPreluWorkload(const PreluQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload(descriptor, info) -{} - -void RefPreluWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefPreluWorkload_Execute"); - - std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(GetTensorInfo(m_Data.m_Inputs[0]), - m_Data.m_Inputs[0]->Map()); - std::unique_ptr<Decoder<float>> alphaDecoder = MakeDecoder<float>(GetTensorInfo(m_Data.m_Inputs[1]), - m_Data.m_Inputs[1]->Map()); - std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(m_Data.m_Outputs[0]), - m_Data.m_Outputs[0]->Map()); - - PreluImpl(m_Data, *inputDecoder, *alphaDecoder, *outputEncoder); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefPreluWorkload.hpp b/src/backends/reference/workloads/RefPreluWorkload.hpp deleted file mode 100644 index 72839e67dc..0000000000 --- a/src/backends/reference/workloads/RefPreluWorkload.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefPreluWorkload : public BaseWorkload<PreluQueueDescriptor> -{ -public: - explicit RefPreluWorkload(const PreluQueueDescriptor& descriptor, - const WorkloadInfo& info); - virtual void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefQuantizeWorkload.cpp b/src/backends/reference/workloads/RefQuantizeWorkload.cpp deleted file mode 100644 index 2eef5f33db..0000000000 --- a/src/backends/reference/workloads/RefQuantizeWorkload.cpp +++ /dev/null @@ -1,54 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefQuantizeWorkload.hpp" - -#include "RefWorkloadUtils.hpp" - -#include <armnn/TypesUtils.hpp> - - -namespace armnn -{ - -namespace -{ - -void QuantizeImpl(Decoder<float>& in, Encoder<float>& out, size_t numValues) -{ - for (unsigned int i = 0; i < numValues; i++) - { - in[i]; - out[i]; - out.Set(in.Get()); - } -} - -} //namespace - -RefQuantizeWorkload::RefQuantizeWorkload(const QuantizeQueueDescriptor& descriptor, const WorkloadInfo &info) - : BaseWorkload(descriptor, info) - , m_NumElements(info.m_InputTensorInfos[0].GetNumElements()) -{ -} - -void RefQuantizeWorkload::PostAllocationConfigure() -{ - const TensorInfo& inputInfo = armnn::GetTensorInfo(m_Data.m_Inputs[0]); - m_InputDecoder = MakeDecoder<float>(inputInfo); - - const TensorInfo& outputInfo = armnn::GetTensorInfo(m_Data.m_Outputs[0]); - m_OutputEncoder = MakeEncoder<float>(outputInfo); -} - -void RefQuantizeWorkload::Execute() const -{ - m_InputDecoder->Reset(m_Data.m_Inputs[0]->Map()); - m_OutputEncoder->Reset(m_Data.m_Outputs[0]->Map()); - - QuantizeImpl(*m_InputDecoder, *m_OutputEncoder, m_NumElements); -} - -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefQuantizeWorkload.hpp b/src/backends/reference/workloads/RefQuantizeWorkload.hpp deleted file mode 100644 index 9ae107607b..0000000000 --- a/src/backends/reference/workloads/RefQuantizeWorkload.hpp +++ /dev/null @@ -1,30 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn { - -class RefQuantizeWorkload : public BaseWorkload<QuantizeQueueDescriptor> -{ -public: - RefQuantizeWorkload(const QuantizeQueueDescriptor& descriptor, const WorkloadInfo &info); - void PostAllocationConfigure() override; - void Execute() const override; - -private: - - std::unique_ptr<Decoder<float>> m_InputDecoder; - std::unique_ptr<Encoder<float>> m_OutputEncoder; - - size_t m_NumElements; -}; - -} //namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefReshapeWorkload.cpp b/src/backends/reference/workloads/RefReshapeWorkload.cpp deleted file mode 100644 index 6d29781937..0000000000 --- a/src/backends/reference/workloads/RefReshapeWorkload.cpp +++ /dev/null @@ -1,25 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefReshapeWorkload.hpp" -#include "RefWorkloadUtils.hpp" -#include "Profiling.hpp" - -#include <cstring> - -namespace armnn -{ - -void RefReshapeWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefReshapeWorkload_Execute"); - - void* output = GetOutputTensorData<void>(0, m_Data); - const void* input = GetInputTensorData<void>(0, m_Data); - unsigned int numBytes = GetTensorInfo(m_Data.m_Inputs[0]).GetNumBytes(); - memcpy(output, input, numBytes); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefReshapeWorkload.hpp b/src/backends/reference/workloads/RefReshapeWorkload.hpp deleted file mode 100644 index 7359ff9cde..0000000000 --- a/src/backends/reference/workloads/RefReshapeWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefReshapeWorkload : public BaseWorkload<ReshapeQueueDescriptor> -{ -public: - using BaseWorkload<ReshapeQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefResizeBilinearWorkload.cpp b/src/backends/reference/workloads/RefResizeBilinearWorkload.cpp deleted file mode 100644 index fc27c0f93d..0000000000 --- a/src/backends/reference/workloads/RefResizeBilinearWorkload.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefResizeBilinearWorkload.hpp" - -#include "RefWorkloadUtils.hpp" -#include "Resize.hpp" -#include "BaseIterator.hpp" -#include "Profiling.hpp" - -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -void RefResizeBilinearWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefResizeBilinearWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - Decoder<float> &decoder = *decoderPtr; - std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - Encoder<float> &encoder = *encoderPtr; - - Resize(decoder, inputInfo, encoder, outputInfo, m_Data.m_Parameters.m_DataLayout, armnn::ResizeMethod::Bilinear); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefResizeBilinearWorkload.hpp b/src/backends/reference/workloads/RefResizeBilinearWorkload.hpp deleted file mode 100644 index 8f86f6fd85..0000000000 --- a/src/backends/reference/workloads/RefResizeBilinearWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefResizeBilinearWorkload : public BaseWorkload<ResizeBilinearQueueDescriptor> -{ -public: - using BaseWorkload<ResizeBilinearQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefResizeWorkload.cpp b/src/backends/reference/workloads/RefResizeWorkload.cpp deleted file mode 100644 index 624b426cbf..0000000000 --- a/src/backends/reference/workloads/RefResizeWorkload.cpp +++ /dev/null @@ -1,41 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefResizeWorkload.hpp" - -#include "RefWorkloadUtils.hpp" -#include "Resize.hpp" -#include "BaseIterator.hpp" -#include "Profiling.hpp" - -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -void RefResizeWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefResizeWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - Decoder<float> &decoder = *decoderPtr; - std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - Encoder<float> &encoder = *encoderPtr; - - Resize(decoder, - inputInfo, - encoder, - outputInfo, - m_Data.m_Parameters.m_DataLayout, - m_Data.m_Parameters.m_Method, - m_Data.m_Parameters.m_BilinearAlignCorners); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefResizeWorkload.hpp b/src/backends/reference/workloads/RefResizeWorkload.hpp deleted file mode 100644 index 1ddfcdfba8..0000000000 --- a/src/backends/reference/workloads/RefResizeWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefResizeWorkload : public BaseWorkload<ResizeQueueDescriptor> -{ -public: - using BaseWorkload<ResizeQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSliceWorkload.cpp b/src/backends/reference/workloads/RefSliceWorkload.cpp deleted file mode 100644 index 2e448450c1..0000000000 --- a/src/backends/reference/workloads/RefSliceWorkload.cpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefSliceWorkload.hpp" - -#include "RefWorkloadUtils.hpp" -#include "Slice.hpp" - -#include <Profiling.hpp> - -namespace armnn -{ - -void RefSliceWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSliceWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - - Slice(inputInfo, - m_Data.m_Parameters, - m_Data.m_Inputs[0]->Map(), - m_Data.m_Outputs[0]->Map(), - GetDataTypeSize(inputInfo.GetDataType())); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefSliceWorkload.hpp b/src/backends/reference/workloads/RefSliceWorkload.hpp deleted file mode 100644 index 006c7b775d..0000000000 --- a/src/backends/reference/workloads/RefSliceWorkload.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefSliceWorkload : public BaseWorkload<SliceQueueDescriptor> -{ -public: - using BaseWorkload<SliceQueueDescriptor>::BaseWorkload; - - virtual void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefSoftmaxWorkload.cpp b/src/backends/reference/workloads/RefSoftmaxWorkload.cpp deleted file mode 100644 index 0f6f837785..0000000000 --- a/src/backends/reference/workloads/RefSoftmaxWorkload.cpp +++ /dev/null @@ -1,40 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefSoftmaxWorkload.hpp" - -#include "Decoders.hpp" -#include "Encoders.hpp" -#include "RefWorkloadUtils.hpp" -#include "Softmax.hpp" - -#include "Profiling.hpp" - -#include <vector> - -namespace armnn -{ - -void RefSoftmaxWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSoftmaxWorkload_Execute"); - - const TensorInfo &inputTensorInfo = GetTensorInfo(m_Data.m_Inputs[0]); - - std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputTensorInfo, m_Data.m_Inputs[0]->Map()); - Decoder<float> &decoder = *decoderPtr; - - const TensorInfo &outputTensorInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputTensorInfo, m_Data.m_Outputs[0]->Map()); - Encoder<float> &encoder = *encoderPtr; - - Softmax(decoder, - encoder, - inputTensorInfo, - m_Data.m_Parameters.m_Beta, - m_Data.m_Parameters.m_Axis); -} -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSoftmaxWorkload.hpp b/src/backends/reference/workloads/RefSoftmaxWorkload.hpp deleted file mode 100644 index cf3623bf40..0000000000 --- a/src/backends/reference/workloads/RefSoftmaxWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefSoftmaxWorkload : public BaseWorkload<SoftmaxQueueDescriptor> -{ -public: - using BaseWorkload<SoftmaxQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSpaceToBatchNdWorkload.cpp b/src/backends/reference/workloads/RefSpaceToBatchNdWorkload.cpp deleted file mode 100644 index 1a721fe389..0000000000 --- a/src/backends/reference/workloads/RefSpaceToBatchNdWorkload.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefSpaceToBatchNdWorkload.hpp" -#include "SpaceToBatchNd.hpp" - -#include "RefWorkloadUtils.hpp" -#include <ResolveType.hpp> - -namespace armnn -{ - -void RefSpaceToBatchNdWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSpaceToBatchNdWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - std::unique_ptr<Decoder<float>> decoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - std::unique_ptr<Encoder<float>> encoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - SpaceToBatchNd(inputInfo, outputInfo, m_Data.m_Parameters, *decoder, *encoder); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSpaceToBatchNdWorkload.hpp b/src/backends/reference/workloads/RefSpaceToBatchNdWorkload.hpp deleted file mode 100644 index 940b910812..0000000000 --- a/src/backends/reference/workloads/RefSpaceToBatchNdWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <backendsCommon/Workload.hpp> - -#include <armnn/TypesUtils.hpp> - -namespace armnn -{ - -class RefSpaceToBatchNdWorkload : public BaseWorkload<SpaceToBatchNdQueueDescriptor> -{ -public: - using BaseWorkload<SpaceToBatchNdQueueDescriptor>::BaseWorkload; - void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSpaceToDepthWorkload.cpp b/src/backends/reference/workloads/RefSpaceToDepthWorkload.cpp deleted file mode 100644 index 1b12272506..0000000000 --- a/src/backends/reference/workloads/RefSpaceToDepthWorkload.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefSpaceToDepthWorkload.hpp" -#include "SpaceToDepth.hpp" - -#include "RefWorkloadUtils.hpp" -#include <ResolveType.hpp> - -namespace armnn -{ - -void RefSpaceToDepthWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSpaceToDepthWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - std::unique_ptr<Decoder<float>> decoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map()); - - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - std::unique_ptr<Encoder<float>> encoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map()); - - SpaceToDepth(inputInfo, outputInfo, m_Data.m_Parameters, *decoder, *encoder); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSpaceToDepthWorkload.hpp b/src/backends/reference/workloads/RefSpaceToDepthWorkload.hpp deleted file mode 100644 index 89e5585249..0000000000 --- a/src/backends/reference/workloads/RefSpaceToDepthWorkload.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#pragma once - -#include <backendsCommon/Workload.hpp> - -#include <armnn/TypesUtils.hpp> - -namespace armnn -{ - -class RefSpaceToDepthWorkload : public BaseWorkload<SpaceToDepthQueueDescriptor> -{ -public: - using BaseWorkload<SpaceToDepthQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSplitterWorkload.cpp b/src/backends/reference/workloads/RefSplitterWorkload.cpp deleted file mode 100644 index ffe4eb880b..0000000000 --- a/src/backends/reference/workloads/RefSplitterWorkload.cpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefSplitterWorkload.hpp" -#include "Splitter.hpp" -#include "RefWorkloadUtils.hpp" -#include "Profiling.hpp" - -namespace armnn -{ - -void RefSplitterWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSplitterWorkload_Execute"); - Split(m_Data); -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefSplitterWorkload.hpp b/src/backends/reference/workloads/RefSplitterWorkload.hpp deleted file mode 100644 index 95cc4a5db7..0000000000 --- a/src/backends/reference/workloads/RefSplitterWorkload.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -class RefSplitterWorkload : public BaseWorkload<SplitterQueueDescriptor> -{ -public: - using BaseWorkload<SplitterQueueDescriptor>::BaseWorkload; - virtual void Execute() const override; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefStackWorkload.cpp b/src/backends/reference/workloads/RefStackWorkload.cpp deleted file mode 100644 index be36f40633..0000000000 --- a/src/backends/reference/workloads/RefStackWorkload.cpp +++ /dev/null @@ -1,57 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefStackWorkload.hpp" - -#include "RefWorkloadUtils.hpp" -#include "Stack.hpp" - -#include <Profiling.hpp> - -namespace armnn -{ - -RefStackWorkload::RefStackWorkload(const StackQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload(descriptor, info) -{} - -void RefStackWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefStackWorkload_Execute"); - - // Can perform a simple concatenation when axis == 0 - if (!m_Data.m_Parameters.m_Axis) - { - float* output = GetOutputTensorData<float>(0, m_Data); - BOOST_ASSERT(output != nullptr); - - unsigned int numInputs = m_Data.m_Parameters.m_NumInputs; - unsigned int inputLength = GetTensorInfo(m_Data.m_Inputs[0]).GetNumElements(); - - for (unsigned int inputIdx=0; inputIdx<numInputs; ++inputIdx) - { - const float* input = GetInputTensorData<float>(inputIdx, m_Data); - for (unsigned int elmt=0; elmt<inputLength; ++elmt) - { - output[(inputIdx * inputLength) + elmt] = input[elmt]; - } - } - return; - } - - std::vector<std::unique_ptr<Decoder<float>>> inputDecoders; - for (unsigned int i=0; i<m_Data.m_Inputs.size(); ++i) - { - inputDecoders.push_back(MakeDecoder<float>(GetTensorInfo(m_Data.m_Inputs[i]), - m_Data.m_Inputs[i]->Map())); - } - std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(m_Data.m_Outputs[0]), - m_Data.m_Outputs[0]->Map()); - - Stack(m_Data, inputDecoders, *outputEncoder); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefStackWorkload.hpp b/src/backends/reference/workloads/RefStackWorkload.hpp deleted file mode 100644 index ceb27d9f60..0000000000 --- a/src/backends/reference/workloads/RefStackWorkload.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -class RefStackWorkload : public BaseWorkload<StackQueueDescriptor> -{ -public: - explicit RefStackWorkload(const StackQueueDescriptor& descriptor, - const WorkloadInfo& info); - virtual void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefStridedSliceWorkload.cpp b/src/backends/reference/workloads/RefStridedSliceWorkload.cpp deleted file mode 100644 index 8bb1670a48..0000000000 --- a/src/backends/reference/workloads/RefStridedSliceWorkload.cpp +++ /dev/null @@ -1,40 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefStridedSliceWorkload.hpp" -#include "RefWorkloadUtils.hpp" -#include "StridedSlice.hpp" - -#include <boost/format.hpp> - -namespace armnn -{ - -RefStridedSliceWorkload::RefStridedSliceWorkload(const StridedSliceQueueDescriptor& descriptor, - const WorkloadInfo& info) - : BaseWorkload(descriptor, info) -{} - -void RefStridedSliceWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefStridedSliceWorkload_Execute"); - - const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]); - const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]); - - DataType inputDataType = inputInfo.GetDataType(); - DataType outputDataType = outputInfo.GetDataType(); - - BOOST_ASSERT(inputDataType == outputDataType); - boost::ignore_unused(outputDataType); - - StridedSlice(inputInfo, - m_Data.m_Parameters, - m_Data.m_Inputs[0]->Map(), - m_Data.m_Outputs[0]->Map(), - GetDataTypeSize(inputDataType)); -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefStridedSliceWorkload.hpp b/src/backends/reference/workloads/RefStridedSliceWorkload.hpp deleted file mode 100644 index 44aabc0106..0000000000 --- a/src/backends/reference/workloads/RefStridedSliceWorkload.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/Workload.hpp> - -namespace armnn -{ - -class RefStridedSliceWorkload : public BaseWorkload<StridedSliceQueueDescriptor> -{ -public: - RefStridedSliceWorkload(const StridedSliceQueueDescriptor& descriptor, const WorkloadInfo& info); - void Execute() const override; -}; - -} // namespace armnn diff --git a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.cpp b/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.cpp deleted file mode 100644 index 2ab76041ef..0000000000 --- a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.cpp +++ /dev/null @@ -1,70 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefTransposeConvolution2dWorkload.hpp" - -#include "RefWorkloadUtils.hpp" -#include "TransposeConvolution2d.hpp" - -#include <Profiling.hpp> - -namespace armnn -{ - -RefTransposeConvolution2dWorkload::RefTransposeConvolution2dWorkload( - const TransposeConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) : - BaseWorkload<TransposeConvolution2dQueueDescriptor>(descriptor, info) -{ - // set up weights decoder - m_Weights = std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Weight)); - const TensorInfo& weightsInfo = m_Weights->GetTensorInfo(); - - m_WeightsDecoder = MakeDecoder<float>(weightsInfo, m_Weights->Map(true)); - m_WeightsShape = weightsInfo.GetShape(); - - // set up biases decoder - if (descriptor.m_Parameters.m_BiasEnabled) - { - m_Biases = std::make_unique<ScopedCpuTensorHandle>(*(descriptor.m_Bias)); - const TensorInfo& biasesInfo = m_Biases->GetTensorInfo(); - m_BiasesDecoder = MakeDecoder<float>(biasesInfo, m_Biases->Map(true)); - } -} - -void RefTransposeConvolution2dWorkload::PostAllocationConfigure() -{ - // set up input decoder - const ITensorHandle* input = m_Data.m_Inputs[0]; - const TensorInfo& inputInfo = GetTensorInfo(input); - - m_InputShape = inputInfo.GetShape(); - m_InputDecoder = MakeDecoder<float>(inputInfo); - - // set up output encoder - ITensorHandle* output = m_Data.m_Outputs[0]; - const TensorInfo& outputInfo = GetTensorInfo(output); - - m_OutputShape = outputInfo.GetShape(); - m_OutputEncoder = MakeEncoder<float>(outputInfo); -} - -void RefTransposeConvolution2dWorkload::Execute() const -{ - ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefTransposeConvolution2dWorkload_Execute"); - - m_InputDecoder->Reset(m_Data.m_Inputs[0]->Map()); - m_OutputEncoder->Reset(m_Data.m_Outputs[0]->Map()); - - TransposeConvolution2dImpl(m_Data.m_Parameters, - m_InputShape, - *m_InputDecoder, - m_OutputShape, - *m_OutputEncoder, - m_WeightsShape, - *m_WeightsDecoder, - m_BiasesDecoder.get()); -} - -} // namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.hpp b/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.hpp deleted file mode 100644 index 9ded8c971f..0000000000 --- a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.hpp +++ /dev/null @@ -1,43 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <backendsCommon/CpuTensorHandle.hpp> -#include <backendsCommon/Workload.hpp> - -namespace armnn -{ - -class RefTransposeConvolution2dWorkload : public BaseWorkload<TransposeConvolution2dQueueDescriptor> -{ -public: - RefTransposeConvolution2dWorkload(const TransposeConvolution2dQueueDescriptor& descriptor, - const WorkloadInfo& info); - ~RefTransposeConvolution2dWorkload() = default; - - void PostAllocationConfigure() override; - - void Execute() const override; - -private: - std::unique_ptr<ScopedCpuTensorHandle> m_Weights; - std::unique_ptr<ScopedCpuTensorHandle> m_Biases; - - std::unique_ptr<Decoder<float>> m_InputDecoder; - std::unique_ptr<Encoder<float>> m_OutputEncoder; - - std::unique_ptr<Decoder<float>> m_WeightsDecoder; - std::unique_ptr<Decoder<float>> m_BiasesDecoder; - - TensorShape m_InputShape; - TensorShape m_OutputShape; - TensorShape m_WeightsShape; -}; - -} // namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefWorkloadUtils.hpp b/src/backends/reference/workloads/RefWorkloadUtils.hpp deleted file mode 100644 index c3260c8142..0000000000 --- a/src/backends/reference/workloads/RefWorkloadUtils.hpp +++ /dev/null @@ -1,103 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <backendsCommon/CpuTensorHandle.hpp> - -#include <armnn/Tensor.hpp> -#include <armnn/Types.hpp> - -#include <reference/RefTensorHandle.hpp> - -#include <Half.hpp> -#include <boost/polymorphic_cast.hpp> - -namespace armnn -{ - -//////////////////////////////////////////// -/// float32 helpers -//////////////////////////////////////////// - -inline const TensorInfo& GetTensorInfo(const ITensorHandle* tensorHandle) -{ - // We know that reference workloads use RefTensorHandles for inputs and outputs - const RefTensorHandle* refTensorHandle = - boost::polymorphic_downcast<const RefTensorHandle*>(tensorHandle); - return refTensorHandle->GetTensorInfo(); -} - -template <typename DataType, typename PayloadType> -const DataType* GetInputTensorData(unsigned int idx, const PayloadType& data) -{ - const ITensorHandle* tensorHandle = data.m_Inputs[idx]; - return reinterpret_cast<const DataType*>(tensorHandle->Map()); -} - -template <typename DataType, typename PayloadType> -DataType* GetOutputTensorData(unsigned int idx, const PayloadType& data) -{ - ITensorHandle* tensorHandle = data.m_Outputs[idx]; - return reinterpret_cast<DataType*>(tensorHandle->Map()); -} - -template <typename PayloadType> -const float* GetInputTensorDataFloat(unsigned int idx, const PayloadType& data) -{ - return GetInputTensorData<float>(idx, data); -} - -template <typename PayloadType> -float* GetOutputTensorDataFloat(unsigned int idx, const PayloadType& data) -{ - return GetOutputTensorData<float>(idx, data); -} - -template <typename PayloadType> -const Half* GetInputTensorDataHalf(unsigned int idx, const PayloadType& data) -{ - return GetInputTensorData<Half>(idx, data); -} - -template <typename PayloadType> -Half* GetOutputTensorDataHalf(unsigned int idx, const PayloadType& data) -{ - return GetOutputTensorData<Half>(idx, data); -} - -//////////////////////////////////////////// -/// u8 helpers -//////////////////////////////////////////// - -template<typename T> -std::vector<float> Dequantize(const T* quant, const TensorInfo& info) -{ - std::vector<float> ret(info.GetNumElements()); - for (size_t i = 0; i < info.GetNumElements(); i++) - { - ret[i] = armnn::Dequantize(quant[i], info.GetQuantizationScale(), info.GetQuantizationOffset()); - } - return ret; -} - -template<typename T> -inline void Dequantize(const T* inputData, float* outputData, const TensorInfo& info) -{ - for (unsigned int i = 0; i < info.GetNumElements(); i++) - { - outputData[i] = Dequantize<T>(inputData[i], info.GetQuantizationScale(), info.GetQuantizationOffset()); - } -} - -inline void Quantize(uint8_t* quant, const float* dequant, const TensorInfo& info) -{ - for (size_t i = 0; i < info.GetNumElements(); i++) - { - quant[i] = armnn::Quantize<uint8_t>(dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset()); - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp deleted file mode 100644 index 7034b67aa5..0000000000 --- a/src/backends/reference/workloads/RefWorkloads.hpp +++ /dev/null @@ -1,65 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Activation.hpp" -#include "ArgMinMax.hpp" -#include "BatchNormImpl.hpp" -#include "ConvImpl.hpp" -#include "Concatenate.hpp" -#include "ElementwiseFunction.hpp" -#include "FullyConnected.hpp" -#include "Gather.hpp" -#include "Pooling2d.hpp" -#include "RefActivationWorkload.hpp" -#include "RefArgMinMaxWorkload.hpp" -#include "RefBatchNormalizationWorkload.hpp" -#include "RefBatchToSpaceNdWorkload.hpp" -#include "RefComparisonWorkload.hpp" -#include "RefConvolution2dWorkload.hpp" -#include "RefConstantWorkload.hpp" -#include "RefConcatWorkload.hpp" -#include "RefConvertFp16ToFp32Workload.hpp" -#include "RefConvertFp32ToFp16Workload.hpp" -#include "RefDebugWorkload.hpp" -#include "RefDepthToSpaceWorkload.hpp" -#include "RefDepthwiseConvolution2dWorkload.hpp" -#include "RefDequantizeWorkload.hpp" -#include "RefDetectionPostProcessWorkload.hpp" -#include "RefDequantizeWorkload.hpp" -#include "RefElementwiseWorkload.hpp" -#include "RefElementwiseUnaryWorkload.hpp" -#include "RefFullyConnectedWorkload.hpp" -#include "RefFloorWorkload.hpp" -#include "RefFakeQuantizationFloat32Workload.hpp" -#include "RefGatherWorkload.hpp" -#include "RefInstanceNormalizationWorkload.hpp" -#include "RefL2NormalizationWorkload.hpp" -#include "RefLogSoftmaxWorkload.hpp" -#include "RefLstmWorkload.hpp" -#include "RefMeanWorkload.hpp" -#include "RefNormalizationWorkload.hpp" -#include "RefPooling2dWorkload.hpp" -#include "RefPermuteWorkload.hpp" -#include "RefPadWorkload.hpp" -#include "RefPreluWorkload.hpp" -#include "RefQuantizeWorkload.hpp" -#include "RefReshapeWorkload.hpp" -#include "RefResizeBilinearWorkload.hpp" -#include "RefResizeWorkload.hpp" -#include "RefSliceWorkload.hpp" -#include "RefSplitterWorkload.hpp" -#include "RefSoftmaxWorkload.hpp" -#include "RefSpaceToBatchNdWorkload.hpp" -#include "RefStackWorkload.hpp" -#include "RefStridedSliceWorkload.hpp" -#include "RefSpaceToDepthWorkload.hpp" -#include "RefTransposeConvolution2dWorkload.hpp" -#include "RefWorkloadUtils.hpp" -#include "Resize.hpp" -#include "Softmax.hpp" -#include "Splitter.hpp" -#include "TensorBufferArrayView.hpp" diff --git a/src/backends/reference/workloads/Resize.cpp b/src/backends/reference/workloads/Resize.cpp deleted file mode 100644 index a26e34a1ff..0000000000 --- a/src/backends/reference/workloads/Resize.cpp +++ /dev/null @@ -1,170 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Resize.hpp" - -#include "TensorBufferArrayView.hpp" - -#include <boost/numeric/conversion/cast.hpp> - -#include <cmath> -#include <algorithm> - -using namespace armnnUtils; - -namespace armnn -{ - -namespace -{ - -inline float Lerp(float a, float b, float w) -{ - return w * b + (1.f - w) * a; -} - -inline double EuclideanDistance(float Xa, float Ya, const unsigned int Xb, const unsigned int Yb) -{ - return std::sqrt(pow(Xa - boost::numeric_cast<float>(Xb), 2) + pow(Ya - boost::numeric_cast<float>(Yb), 2)); -} - -}// anonymous namespace - -void Resize(Decoder<float>& in, - const TensorInfo& inputInfo, - Encoder<float>& out, - const TensorInfo& outputInfo, - DataLayoutIndexed dataLayout, - armnn::ResizeMethod resizeMethod, - bool alignCorners) -{ - // We follow the definition of TensorFlow and AndroidNN: the top-left corner of a texel in the output - // image is projected into the input image to figure out the interpolants and weights. Note that this - // will yield different results than if projecting the centre of output texels. - - const unsigned int batchSize = inputInfo.GetShape()[0]; - const unsigned int channelCount = inputInfo.GetShape()[dataLayout.GetChannelsIndex()]; - - const unsigned int inputHeight = inputInfo.GetShape()[dataLayout.GetHeightIndex()]; - const unsigned int inputWidth = inputInfo.GetShape()[dataLayout.GetWidthIndex()]; - const unsigned int outputHeight = outputInfo.GetShape()[dataLayout.GetHeightIndex()]; - const unsigned int outputWidth = outputInfo.GetShape()[dataLayout.GetWidthIndex()]; - - const unsigned int sizeOffset = resizeMethod == armnn::ResizeMethod::Bilinear && alignCorners ? 1 : 0; - - // How much to scale pixel coordinates in the output image, to get the corresponding pixel coordinates - // in the input image. - const float scaleY = boost::numeric_cast<float>(inputHeight - sizeOffset) - / boost::numeric_cast<float>(outputHeight - sizeOffset); - const float scaleX = boost::numeric_cast<float>(inputWidth - sizeOffset) - / boost::numeric_cast<float>(outputWidth - sizeOffset); - - TensorShape inputShape = inputInfo.GetShape(); - TensorShape outputShape = outputInfo.GetShape(); - - for (unsigned int n = 0; n < batchSize; ++n) - { - for (unsigned int c = 0; c < channelCount; ++c) - { - for (unsigned int y = 0; y < outputHeight; ++y) - { - // Corresponding real-valued height coordinate in input image. - const float iy = boost::numeric_cast<float>(y) * scaleY; - - // Discrete height coordinate of top-left texel (in the 2x2 texel area used for interpolation). - const float fiy = floorf(iy); - const unsigned int y0 = boost::numeric_cast<unsigned int>(fiy); - - // Interpolation weight (range [0,1]). - const float yw = iy - fiy; - - for (unsigned int x = 0; x < outputWidth; ++x) - { - // Real-valued and discrete width coordinates in input image. - const float ix = boost::numeric_cast<float>(x) * scaleX; - const float fix = floorf(ix); - const unsigned int x0 = boost::numeric_cast<unsigned int>(fix); - - // Interpolation weight (range [0,1]). - const float xw = ix - fix; - - // Discrete width/height coordinates of texels below and to the right of (x0, y0). - const unsigned int x1 = std::min(x0 + 1, inputWidth - 1u); - const unsigned int y1 = std::min(y0 + 1, inputHeight - 1u); - - float interpolatedValue; - switch (resizeMethod) - { - case armnn::ResizeMethod::Bilinear: - { - in[dataLayout.GetIndex(inputShape, n, c, y0, x0)]; - float input1 = in.Get(); - in[dataLayout.GetIndex(inputShape, n, c, y0, x1)]; - float input2 = in.Get(); - in[dataLayout.GetIndex(inputShape, n, c, y1, x0)]; - float input3 = in.Get(); - in[dataLayout.GetIndex(inputShape, n, c, y1, x1)]; - float input4 = in.Get(); - - const float ly0 = Lerp(input1, input2, xw); // lerp along row y0. - const float ly1 = Lerp(input3, input4, xw); // lerp along row y1. - interpolatedValue = Lerp(ly0, ly1, yw); - break; - } - case armnn::ResizeMethod::NearestNeighbor: - { - // calculate euclidean distance to the 4 neighbours - auto distance00 = EuclideanDistance(fix, fiy, x0, y0); - auto distance01 = EuclideanDistance(fix, fiy, x0, y1); - auto distance10 = EuclideanDistance(fix, fiy, x1, y0); - auto distance11 = EuclideanDistance(fix, fiy, x1, y1); - - auto minimum = std::min( { distance00, distance01, distance10, distance11 } ); - - unsigned int xNearest = 0; - unsigned int yNearest = 0; - - if (minimum == distance00) - { - xNearest = x0; - yNearest = y0; - } - else if (minimum == distance01) - { - xNearest = x0; - yNearest = y1; - } - else if (minimum == distance10) - { - xNearest = x1; - yNearest = y0; - } - else if (minimum == distance11) - { - xNearest = x1; - yNearest = y1; - } - else - { - throw armnn::InvalidArgumentException("Resize Nearest Neighbor failure"); - } - - in[dataLayout.GetIndex(inputShape, n, c, yNearest, xNearest)]; - interpolatedValue = in.Get(); - break; - } - default: - throw armnn::InvalidArgumentException("Unknown resize method: " + - std::to_string(static_cast<int>(resizeMethod))); - } - out[dataLayout.GetIndex(outputShape, n, c, y, x)]; - out.Set(interpolatedValue); - } - } - } - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/Resize.hpp b/src/backends/reference/workloads/Resize.hpp deleted file mode 100644 index cd8835fa08..0000000000 --- a/src/backends/reference/workloads/Resize.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" - -#include <armnn/Tensor.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -namespace armnn -{ - -void Resize(Decoder<float>& in, - const TensorInfo& inputInfo, - Encoder<float>& out, - const TensorInfo& outputInfo, - armnnUtils::DataLayoutIndexed dataLayout = DataLayout::NCHW, - ResizeMethod resizeMethod = ResizeMethod::NearestNeighbor, - bool alignConers = false); - -} // namespace armnn diff --git a/src/backends/reference/workloads/Rsqrt.hpp b/src/backends/reference/workloads/Rsqrt.hpp deleted file mode 100644 index 47ebcf36f6..0000000000 --- a/src/backends/reference/workloads/Rsqrt.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <iostream> - -namespace armnn -{ - template<typename T> -struct rsqrt : public std::unary_function<T, T> - { - T - operator () (const T& inputData) const - { - return 1 / std::sqrt(inputData); - } - }; - -} //namespace armnn diff --git a/src/backends/reference/workloads/Slice.cpp b/src/backends/reference/workloads/Slice.cpp deleted file mode 100644 index c7ca3b156e..0000000000 --- a/src/backends/reference/workloads/Slice.cpp +++ /dev/null @@ -1,95 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Slice.hpp" - -#include <boost/assert.hpp> -#include <boost/core/ignore_unused.hpp> -#include <boost/numeric/conversion/cast.hpp> - -namespace armnn -{ - -void Slice(const TensorInfo& inputInfo, - const SliceDescriptor& descriptor, - const void* inputData, - void* outputData, - unsigned int dataTypeSize) -{ - const TensorShape& inputShape = inputInfo.GetShape(); - const unsigned int numDims = inputShape.GetNumDimensions(); - - BOOST_ASSERT(descriptor.m_Begin.size() == numDims); - BOOST_ASSERT(descriptor.m_Size.size() == numDims); - - constexpr unsigned int maxNumDims = 4; - BOOST_ASSERT(numDims <= maxNumDims); - - std::vector<unsigned int> paddedInput(4); - std::vector<unsigned int> paddedBegin(4); - std::vector<unsigned int> paddedSize (4); - - const unsigned int numPaddingDims = maxNumDims - numDims; - for (unsigned int i = 0u; i < maxNumDims; ++i) - { - if (i < numPaddingDims) - { - paddedInput[i] = 1u; - paddedBegin[i] = 0u; - paddedSize[i] = 1u; - } - else - { - const unsigned int j = i - numPaddingDims; - paddedInput[i] = inputShape[j]; - paddedBegin[i] = descriptor.m_Begin[j]; - paddedSize[i] = descriptor.m_Size[j]; - } - } - - unsigned int dim0 = paddedInput[0]; - unsigned int dim1 = paddedInput[1]; - unsigned int dim2 = paddedInput[2]; - unsigned int dim3 = paddedInput[3]; - - unsigned int begin0 = paddedBegin[0]; - unsigned int begin1 = paddedBegin[1]; - unsigned int begin2 = paddedBegin[2]; - unsigned int begin3 = paddedBegin[3]; - - unsigned int size0 = paddedSize[0]; - unsigned int size1 = paddedSize[1]; - unsigned int size2 = paddedSize[2]; - unsigned int size3 = paddedSize[3]; - - BOOST_ASSERT(begin0 + size0 <= dim0); - BOOST_ASSERT(begin1 + size1 <= dim1); - BOOST_ASSERT(begin2 + size2 <= dim2); - BOOST_ASSERT(begin3 + size3 <= dim3); - - const unsigned char* input = reinterpret_cast<const unsigned char*>(inputData); - unsigned char* output = reinterpret_cast<unsigned char*>(outputData); - - boost::ignore_unused(dim0); - for (unsigned int idx0 = begin0; idx0 < begin0 + size0; ++idx0) - { - for (unsigned int idx1 = begin1; idx1 < begin1 + size1; ++idx1) - { - for (unsigned int idx2 = begin2; idx2 < begin2 + size2; ++idx2) - { - for (unsigned int idx3 = begin3; idx3 < begin3 + size3; ++idx3) - { - const unsigned int inputOffset = - (((idx0 * dim1 + idx1) * dim2 + idx2) * dim3 + idx3) * dataTypeSize; - - ::memcpy(output, input + inputOffset, dataTypeSize); - output += dataTypeSize; - } - } - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/Slice.hpp b/src/backends/reference/workloads/Slice.hpp deleted file mode 100644 index 8559eb890e..0000000000 --- a/src/backends/reference/workloads/Slice.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Descriptors.hpp> - -#include "BaseIterator.hpp" - - -namespace armnn -{ - -void Slice(const TensorInfo& inputInfo, - const SliceDescriptor& descriptor, - const void* inputData, - void* outputData, - unsigned int dataTypeSize); - -} // namespace armnn diff --git a/src/backends/reference/workloads/Softmax.cpp b/src/backends/reference/workloads/Softmax.cpp deleted file mode 100644 index 5036389a10..0000000000 --- a/src/backends/reference/workloads/Softmax.cpp +++ /dev/null @@ -1,72 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Softmax.hpp" - -#include <armnnUtils/TensorUtils.hpp> - -#include <cmath> -#include <vector> - -namespace armnn -{ - -/// Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo. -void Softmax(Decoder<float>& in, Encoder<float>& out, const TensorInfo& inputTensorInfo, float beta, int axis) -{ - BOOST_ASSERT_MSG(axis < static_cast<int>(inputTensorInfo.GetNumDimensions()), - "Required axis index greater than number of dimensions."); - BOOST_ASSERT_MSG(axis >= -static_cast<int>(inputTensorInfo.GetNumDimensions()), - "Required axis index lower than negative of the number of dimensions"); - - unsigned int uAxis = axis < 0 ? - inputTensorInfo.GetNumDimensions() - static_cast<unsigned int>(abs(axis)) - : static_cast<unsigned int>(axis); - - const TensorShape& inputShape = inputTensorInfo.GetShape(); - const unsigned int outerSize = armnnUtils::GetNumElementsBetween(inputShape, 0, uAxis); - const unsigned int axisSize = inputShape[uAxis]; - const unsigned int innerSize = armnnUtils::GetNumElementsBetween(inputShape, - uAxis + 1, - inputShape.GetNumDimensions()); - - for (unsigned int outer = 0; outer < outerSize; ++outer) - { - unsigned int inputBeginIdx = outer * axisSize * innerSize; - unsigned int inputEndIdx = inputBeginIdx + axisSize * innerSize; - unsigned int outputBeginIdx = outer * axisSize * innerSize; - - for (unsigned int inner = 0; inner < innerSize; ++inner, ++inputBeginIdx, ++inputEndIdx, ++outputBeginIdx) - { - // Find max - float maxValue = std::numeric_limits<float>::lowest(); - for (unsigned int iter = inputBeginIdx; iter < inputEndIdx; iter += innerSize) - { - in[iter]; - maxValue = std::max(maxValue, in.Get()); - } - - // Compute sum - float sum = 0.0f; - for (unsigned int iter = inputBeginIdx; iter < inputEndIdx; iter += innerSize) - { - in[iter]; - sum += std::exp((in.Get() - maxValue) * beta); - } - - // Compute result - unsigned int outputIter = outputBeginIdx; - out[outputIter]; - for (unsigned int iter = inputBeginIdx; iter < inputEndIdx; iter += innerSize, outputIter += innerSize) - { - out[outputIter]; - in[iter]; - out.Set(std::exp((in.Get() - maxValue) * beta) / sum); - } - } - } -} - -} //namespace armnn diff --git a/src/backends/reference/workloads/Softmax.hpp b/src/backends/reference/workloads/Softmax.hpp deleted file mode 100644 index 25c7449474..0000000000 --- a/src/backends/reference/workloads/Softmax.hpp +++ /dev/null @@ -1,17 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" -#include <armnn/Tensor.hpp> - -namespace armnn -{ - -/// Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo. -void Softmax(Decoder<float>& in, Encoder<float>& out, const TensorInfo& inputTensorInfo, float beta, int axis = -1); - -} //namespace armnn diff --git a/src/backends/reference/workloads/SpaceToBatchNd.cpp b/src/backends/reference/workloads/SpaceToBatchNd.cpp deleted file mode 100644 index b6bab17367..0000000000 --- a/src/backends/reference/workloads/SpaceToBatchNd.cpp +++ /dev/null @@ -1,126 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "SpaceToBatchNd.hpp" - -#include <armnnUtils/DataLayoutIndexed.hpp> - -using namespace armnnUtils; - -namespace armnn -{ - -unsigned int GetOffset(const TensorShape& shape, - unsigned int b, - unsigned int h, - unsigned int w, - unsigned int c, - const DataLayoutIndexed& dataLayout) -{ - if (dataLayout.GetDataLayout() == DataLayout::NHWC) - { - return ((b * shape[dataLayout.GetHeightIndex()] + h) * shape[dataLayout.GetWidthIndex()] + w) * - shape[dataLayout.GetChannelsIndex()] + c; - } - else - { - return ((b * shape[dataLayout.GetChannelsIndex()] + c) * shape[dataLayout.GetHeightIndex()] + h) * - shape[dataLayout.GetWidthIndex()] + w; - } -} - -void SpaceToBatchNd(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const SpaceToBatchNdDescriptor& params, - Decoder<float>& inputData, - Encoder<float>& outputData) -{ - DataLayoutIndexed dataLayout = params.m_DataLayout; - - const TensorShape& inputShape = inputInfo.GetShape(); - const TensorShape& outputShape = outputInfo.GetShape(); - - const unsigned int channels = inputShape[dataLayout.GetChannelsIndex()]; - - const unsigned int inputBatchSize = inputShape[0]; - const unsigned int inputHeight = inputShape[dataLayout.GetHeightIndex()]; - const unsigned int inputWidth = inputShape[dataLayout.GetWidthIndex()]; - - const unsigned int outputBatchSize = outputShape[0]; - const unsigned int outputHeight = outputShape[dataLayout.GetHeightIndex()]; - const unsigned int outputWidth = outputShape[dataLayout.GetWidthIndex()]; - - const unsigned int blockHeight = params.m_BlockShape[0]; - const unsigned int blockWidth = params.m_BlockShape[1]; - - const unsigned int paddingTop = params.m_PadList[0].first; - const unsigned int paddingLeft = params.m_PadList[1].first; - - for (unsigned int outB = 0; outB < outputBatchSize; outB++) - { - unsigned int inB = outB % inputBatchSize; - - unsigned int shiftW = (outB / inputBatchSize) % blockWidth; - unsigned int shiftH = (outB / inputBatchSize) / blockWidth; - - for (unsigned int outH = 0; outH < outputHeight; outH++) - { - for (unsigned int outW = 0; outW < outputWidth; outW++) - { - if (outH * blockHeight + shiftH < paddingTop || - outH * blockHeight + shiftH >= paddingTop + inputHeight || - outW * blockWidth + shiftW < paddingLeft || - outW * blockWidth + shiftW >= paddingLeft + inputWidth) - { - for (unsigned int c = 0; c < channels; c++) - { - unsigned int outOffset = GetOffset(outputShape, - outB, - outH, - outW, - c, - dataLayout); - outputData += outOffset; - outputData.Set(0); - outputData -= outOffset; - } - } - else - { - for (unsigned int c = 0; c < channels; c++) - { - unsigned int inOffset = GetOffset(inputShape, - inB, - (outH * blockHeight + shiftH) - paddingTop, - (outW * blockWidth + shiftW) - paddingLeft, - c, - dataLayout); - - unsigned int outOffset = GetOffset(outputShape, - outB, - outH, - outW, - c, - dataLayout); - - outputData += outOffset; - inputData += inOffset; - outputData.Set(inputData.Get()); - inputData -= inOffset; - outputData -= outOffset; - } - } - } - } - } -} - -void SpaceToBatchNd(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const SpaceToBatchNdDescriptor& params, - Decoder<float>& inputData, - Encoder<float>& outData); - -} //namespace armnn diff --git a/src/backends/reference/workloads/SpaceToBatchNd.hpp b/src/backends/reference/workloads/SpaceToBatchNd.hpp deleted file mode 100644 index 57c9b6bc25..0000000000 --- a/src/backends/reference/workloads/SpaceToBatchNd.hpp +++ /dev/null @@ -1,24 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <armnn/Descriptors.hpp> -#include "armnn/Tensor.hpp" - -namespace armnn -{ - -void SpaceToBatchNd(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const SpaceToBatchNdDescriptor& params, - Decoder<float>& inputData, - Encoder<float>& outputData); - -} //namespace armnn diff --git a/src/backends/reference/workloads/SpaceToDepth.cpp b/src/backends/reference/workloads/SpaceToDepth.cpp deleted file mode 100644 index 604a9051af..0000000000 --- a/src/backends/reference/workloads/SpaceToDepth.cpp +++ /dev/null @@ -1,107 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "SpaceToDepth.hpp" - -#include <armnnUtils/DataLayoutIndexed.hpp> - -using namespace armnnUtils; - -namespace { - unsigned int GetOffset(const armnn::TensorShape& shape, - unsigned int c, - unsigned int h, - unsigned int w, - unsigned int b, - const DataLayoutIndexed& dataLayout) - { - if (dataLayout.GetDataLayout() == armnn::DataLayout::NHWC) - { - return ((b * shape[dataLayout.GetHeightIndex()] + h) * shape[dataLayout.GetWidthIndex()] + w) * - shape[dataLayout.GetChannelsIndex()] + c; - } - else - { - return ((b * shape[dataLayout.GetChannelsIndex()] + c) * shape[dataLayout.GetHeightIndex()] + h) * - shape[dataLayout.GetWidthIndex()] + w; - } - } -} - -namespace armnn -{ - -void SpaceToDepth(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const SpaceToDepthDescriptor& params, - Decoder<float>& inputData, - Encoder<float>& outputData) -{ - DataLayoutIndexed dataLayout = params.m_DataLayout; - - const TensorShape& inputShape = inputInfo.GetShape(); - const TensorShape& outputShape = outputInfo.GetShape(); - - const unsigned int inputBatchSize = inputShape[0]; - const unsigned int inputChannels = inputShape[dataLayout.GetChannelsIndex()]; - - const unsigned int outputHeight = outputShape[dataLayout.GetHeightIndex()]; - const unsigned int outputWidth = outputShape[dataLayout.GetWidthIndex()]; - const unsigned int outputChannels = outputShape[dataLayout.GetChannelsIndex()]; - - const unsigned int blockSize = params.m_BlockSize; - - if (blockSize == 0) - { - throw InvalidArgumentException( - "Input shape must be divisible by block size in all spatial dimensions: Block size is" - " equal to zero"); - } - - for (unsigned int outChannelIndex = 0; outChannelIndex < outputChannels; outChannelIndex++) - { - unsigned int inChannelIndex = outChannelIndex % inputChannels; - - unsigned int shiftW = (outChannelIndex / inputChannels) % blockSize; - unsigned int shiftH = (outChannelIndex / inputChannels) / blockSize; - - for (unsigned int outH = 0; outH < outputHeight; outH++) - { - for (unsigned int outW = 0; outW < outputWidth; outW++) - { - for (unsigned int inBatchIndex = 0; inBatchIndex < inputBatchSize; inBatchIndex++) - { - unsigned int inOffset = GetOffset(inputShape, - inChannelIndex, - (outH * blockSize + shiftH), - (outW * blockSize + shiftW), - inBatchIndex, - dataLayout); - - unsigned int outOffset = GetOffset(outputShape, - outChannelIndex, - outH, - outW, - inBatchIndex, - dataLayout); - - outputData += outOffset; - inputData += inOffset; - outputData.Set(inputData.Get()); - inputData -= inOffset; - outputData -= outOffset; - } - } - } - } -} - -void SpaceToDepth(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const SpaceToDepthDescriptor& params, - Decoder<float>& inputData, - Encoder<float>& outData); - -} //namespace armnn diff --git a/src/backends/reference/workloads/SpaceToDepth.hpp b/src/backends/reference/workloads/SpaceToDepth.hpp deleted file mode 100644 index f855884e94..0000000000 --- a/src/backends/reference/workloads/SpaceToDepth.hpp +++ /dev/null @@ -1,24 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "BaseIterator.hpp" -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <armnn/Descriptors.hpp> -#include <armnn/Tensor.hpp> - -namespace armnn -{ - -void SpaceToDepth(const TensorInfo& inputInfo, - const TensorInfo& outputInfo, - const SpaceToDepthDescriptor& params, - Decoder<float>& inputData, - Encoder<float>& outputData); - -} //namespace armnn diff --git a/src/backends/reference/workloads/Splitter.cpp b/src/backends/reference/workloads/Splitter.cpp deleted file mode 100644 index 3bddfb0cab..0000000000 --- a/src/backends/reference/workloads/Splitter.cpp +++ /dev/null @@ -1,94 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "RefWorkloadUtils.hpp" -#include <backendsCommon/WorkloadData.hpp> -#include <armnn/Tensor.hpp> - -#include <boost/assert.hpp> -#include "Splitter.hpp" - -#include <cmath> -#include <limits> - -#include "Decoders.hpp" -#include "Encoders.hpp" - -namespace armnn -{ - -void Split(const SplitterQueueDescriptor& data) -{ - const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]); - - std::unique_ptr<Decoder<float>> decoderPtr = - MakeDecoder<float>(inputInfo, data.m_Inputs[0]->Map()); - Decoder<float>& decoder = *decoderPtr; - - for (unsigned int index = 0; index < inputInfo.GetNumElements(); ++index) - { - unsigned int indices[MaxNumOfTensorDimensions] = { 0 }; - - unsigned int indexRemainder = index; - unsigned int dimensionStride = inputInfo.GetNumElements(); - - for (unsigned int i = 0; i<inputInfo.GetNumDimensions(); i++) - { - dimensionStride /= inputInfo.GetShape()[i]; - indices[i] = indexRemainder / dimensionStride; // Use integer division to round down. - indexRemainder -= indices[i] * dimensionStride; - } - - for (unsigned int viewIdx = 0; viewIdx < data.m_ViewOrigins.size(); ++viewIdx) - { - SplitterQueueDescriptor::ViewOrigin const& view = data.m_ViewOrigins[viewIdx]; - - //Split view extents are defined by the size of (the corresponding) input tensor. - const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[viewIdx]); - BOOST_ASSERT(outputInfo.GetNumDimensions() == inputInfo.GetNumDimensions()); - - // Check all dimensions to see if this element is inside the given input view. - bool insideView = true; - for (unsigned int i = 0; i<outputInfo.GetNumDimensions(); i++) - { - if (indices[i] < view.m_Origin[i]) - { - insideView = false; - } - if (indices[i] >= view.m_Origin[i] + outputInfo.GetShape()[i]) - { - insideView = false; - } - } - - if (insideView) - { - std::unique_ptr<Encoder<float>> encoderPtr = - MakeEncoder<float>(outputInfo, data.m_Outputs[viewIdx]->Map()); - Encoder<float>& encoder = *encoderPtr; - - unsigned int outIndex = 0; - unsigned int dimensionStride = 1; - float inputValue = 0.f; - - for (unsigned int i = outputInfo.GetNumDimensions(); i-- > 0;) - { - outIndex += dimensionStride * (indices[i] - view.m_Origin[i]); - dimensionStride *= outputInfo.GetShape()[i]; - } - - decoder += index; - inputValue = decoder.Get(); - decoder -= index; - - encoder += outIndex; - encoder.Set(inputValue); - break; - } - } - } -} - -}
\ No newline at end of file diff --git a/src/backends/reference/workloads/Splitter.hpp b/src/backends/reference/workloads/Splitter.hpp deleted file mode 100644 index 271c6fdeb8..0000000000 --- a/src/backends/reference/workloads/Splitter.hpp +++ /dev/null @@ -1,82 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "RefWorkloadUtils.hpp" -#include <backendsCommon/WorkloadData.hpp> -#include <armnn/Tensor.hpp> -#include <boost/assert.hpp> - -namespace armnn -{ - -template <typename DataType> -void Splitter(const SplitterQueueDescriptor& data) -{ - const TensorInfo& inputInfo0 = GetTensorInfo(data.m_Inputs[0]); - - for (unsigned int index = 0; index < inputInfo0.GetNumElements(); ++index) - { - unsigned int indices[MaxNumOfTensorDimensions] = { 0 }; - - unsigned int indexRemainder = index; - unsigned int dimensionStride = inputInfo0.GetNumElements(); - - for (unsigned int i = 0; i<inputInfo0.GetNumDimensions(); i++) - { - dimensionStride /= inputInfo0.GetShape()[i]; - indices[i] = indexRemainder / dimensionStride; // Use integer division to round down. - indexRemainder -= indices[i] * dimensionStride; - } - - for (unsigned int viewIdx = 0; viewIdx < data.m_ViewOrigins.size(); ++viewIdx) - { - SplitterQueueDescriptor::ViewOrigin const& view = data.m_ViewOrigins[viewIdx]; - - //Split view extents are defined by the size of (the corresponding) input tensor. - const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[viewIdx]); - BOOST_ASSERT(outputInfo.GetNumDimensions() == inputInfo0.GetNumDimensions()); - - // Check all dimensions to see if this element is inside the given input view. - bool insideView = true; - for (unsigned int i = 0; i<outputInfo.GetNumDimensions(); i++) - { - if (indices[i] < view.m_Origin[i]) - { - insideView = false; - } - if (indices[i] >= view.m_Origin[i] + outputInfo.GetShape()[i]) - { - insideView = false; - } - } - - if (insideView) - { - unsigned int outIndex = 0; - unsigned int dimensionStride = 1; - - for (unsigned int i = outputInfo.GetNumDimensions(); i-- > 0;) - { - outIndex += dimensionStride * (indices[i] - view.m_Origin[i]); - dimensionStride *= outputInfo.GetShape()[i]; - } - - //We are within the view, to copy input data to the output corresponding to this view. - DataType* outputData = GetOutputTensorData<DataType>(viewIdx, data); - BOOST_ASSERT(outputData); - - const DataType* inputData = GetInputTensorData<DataType>(0, data); - BOOST_ASSERT(inputData); - - outputData[outIndex] = inputData[index]; - } - } - } -} - -void Split(const SplitterQueueDescriptor& data); -} //namespace armnn diff --git a/src/backends/reference/workloads/Sqrt.hpp b/src/backends/reference/workloads/Sqrt.hpp deleted file mode 100644 index e4ff6a4829..0000000000 --- a/src/backends/reference/workloads/Sqrt.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <iostream> - -namespace armnn -{ - template<typename T> -struct sqrt : public std::unary_function<T, T> - { - T - operator () (const T& inputData) const - { - return std::sqrt(inputData); - } - }; - -} //namespace armnn diff --git a/src/backends/reference/workloads/Stack.cpp b/src/backends/reference/workloads/Stack.cpp deleted file mode 100644 index 386c8992eb..0000000000 --- a/src/backends/reference/workloads/Stack.cpp +++ /dev/null @@ -1,115 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "Stack.hpp" -#include "RefWorkloadUtils.hpp" - -namespace armnn -{ - -void Stack(const StackQueueDescriptor& data, - std::vector<std::unique_ptr<Decoder<float>>>& inputs, - Encoder<float>& output) -{ - const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[0]); - const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]); - - unsigned int outputNumDims = outputInfo.GetNumDimensions(); - unsigned int inputNumDims = inputInfo.GetNumDimensions(); - - const armnn::TensorShape& outputDims = outputInfo.GetShape(); - const armnn::TensorShape& inputDims = inputInfo.GetShape(); - - unsigned int axis = data.m_Parameters.m_Axis; - - // Initialise output data - unsigned int numOutputElements = 1; - for (unsigned int i=0; i<outputNumDims; ++i) - { - numOutputElements *= outputDims[i]; - } - - const unsigned int iNumTensors = static_cast<unsigned int>(data.m_Inputs.size()); - const unsigned int iBatchSize = inputDims[0]; - const unsigned int iChannels = (inputNumDims > 1) ? inputDims[1] : 1; - const unsigned int iHeight = (inputNumDims > 2) ? inputDims[2] : 1; - const unsigned int iWidth = (inputNumDims > 3) ? inputDims[3] : 1; - - const unsigned int oBatchSize = outputDims[1]; - const unsigned int oChannels = (outputNumDims > 2) ? outputDims[2] : 1; - const unsigned int oHeight = (outputNumDims > 3) ? outputDims[3] : 1; - const unsigned int oWidth = (outputNumDims > 4) ? outputDims[4] : 1; - - // Array to store the input coordinates - // iCoordinates[0] = i, iCoordinates[1] = bi, iCoordinates[2] = ci - // iCoordinates[3] = hi, iCoordinates[4] = wi, iCoordinates[5] = 0 - // iCoordinates[5] will be always zero and used for not incrementing - // the output when the input has less than 4 dimensions - std::array<unsigned int, 6> iCoordinates{ 0 }; - - // Array of pointers used to map the output coordinates to the input ones, in accordance with the axis - // This array is initialized with &iCoordinates[5] since this will be always zero - std::array<unsigned int *, 5> oCoordinates = { &iCoordinates[5], - &iCoordinates[5], - &iCoordinates[5], - &iCoordinates[5], - &iCoordinates[5] }; - - // Set the axis coordinate - oCoordinates[axis] = &iCoordinates[0]; - - // Map the output coordinates, accounting for the axis - unsigned int dim_shift = 0; - for(unsigned int dim = 0; dim < inputNumDims; ++dim) - { - if(dim == axis) - { - dim_shift++; - } - oCoordinates[dim + dim_shift] = &iCoordinates[dim + 1]; - } - - // Alias for the input coordinates - unsigned int &i = iCoordinates[0]; - unsigned int &bi = iCoordinates[1]; - unsigned int &ci = iCoordinates[2]; - unsigned int &hi = iCoordinates[3]; - unsigned int &wi = iCoordinates[4]; - - // Alias for the output coordinates - unsigned int &o = *(oCoordinates[0]); - unsigned int &bo = *(oCoordinates[1]); - unsigned int &co = *(oCoordinates[2]); - unsigned int &ho = *(oCoordinates[3]); - unsigned int &wo = *(oCoordinates[4]); - - // Stack tensors - for(; i < iNumTensors; ++(i)) - { - for(bi = 0; bi < iBatchSize; ++(bi)) - { - for(ci = 0; ci < iChannels; ++(ci)) - { - for(hi = 0; hi < iHeight; ++(hi)) - { - for(wi = 0; wi < iWidth; ++(wi)) - { - output[o * oWidth * oHeight * oChannels * oBatchSize + - bo * oWidth * oHeight * oChannels + - co * oWidth * oHeight + - ho * oWidth + - wo]; - - output.Set(inputs[i]->Get()); - - ++(*(inputs[i])); - } - } - } - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/Stack.hpp b/src/backends/reference/workloads/Stack.hpp deleted file mode 100644 index cd86d41552..0000000000 --- a/src/backends/reference/workloads/Stack.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Encoders.hpp" -#include "Decoders.hpp" - -#include <backendsCommon/WorkloadData.hpp> - -namespace armnn -{ - -void Stack (const StackQueueDescriptor& data, - std::vector<std::unique_ptr<Decoder<float>>>& inputs, - Encoder<float>& output); - -} // namespace armnn diff --git a/src/backends/reference/workloads/StridedSlice.cpp b/src/backends/reference/workloads/StridedSlice.cpp deleted file mode 100644 index 62f06dc5ec..0000000000 --- a/src/backends/reference/workloads/StridedSlice.cpp +++ /dev/null @@ -1,149 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "StridedSlice.hpp" - -#include <ResolveType.hpp> - -#include <boost/assert.hpp> -#include <boost/numeric/conversion/cast.hpp> - -#include <cstring> - -namespace armnn -{ - -namespace -{ - -void PadParams(StridedSliceDescriptor& p, unsigned int dimCount) -{ - BOOST_ASSERT_MSG(dimCount <= 4, "Expected input with at most 4 dimensions"); - - const unsigned int beginIndicesCount = - boost::numeric_cast<unsigned int>(p.m_Begin.size()); - - BOOST_ASSERT(dimCount >= beginIndicesCount); - const unsigned int padCount = dimCount - beginIndicesCount; - - p.m_Begin.resize(dimCount); - p.m_End.resize(dimCount); - p.m_Stride.resize(dimCount); - - for (unsigned int i = beginIndicesCount; i > 0; --i) - { - p.m_Stride[i + padCount - 1] = p.m_Stride[i - 1]; - p.m_Begin[i + padCount - 1] = p.m_Begin[i - 1]; - p.m_End[i + padCount - 1] = p.m_End[i - 1]; - } - - for (unsigned int i = 0; i < padCount; ++i) - { - p.m_Stride[i] = 1; - p.m_Begin[i] = 0; - p.m_End[i] = 0; - } - - p.m_ShrinkAxisMask <<= padCount; - p.m_EllipsisMask <<= padCount; - p.m_NewAxisMask <<= padCount; - p.m_BeginMask <<= padCount; - p.m_EndMask <<= padCount; - p.m_BeginMask |= (1 << padCount) - 1; - p.m_EndMask |= (1 << padCount) - 1; -} - -bool LoopCondition(int index, int stop, int stride) -{ - return stride > 0 ? index >= stop : index <= stop; -} - -TensorShape ExtendShape(const TensorShape& inputShape, - unsigned int newNumDimensions) -{ - if (inputShape.GetNumDimensions() >= newNumDimensions) - { - return inputShape; - } - - std::vector<unsigned int> newSizes(newNumDimensions, 0); - - unsigned int diff = newNumDimensions - inputShape.GetNumDimensions(); - - for (unsigned int i = 0; i < diff; i++) - { - newSizes[i] = 1; - } - - for (unsigned int i = diff; i < newNumDimensions; i++) - { - newSizes[i] = inputShape[i - diff]; - } - - return TensorShape(newNumDimensions, newSizes.data()); -} - -} // Anonymous namespace - -void StridedSlice(const TensorInfo& inputInfo, - const StridedSliceDescriptor& params, - const void* inputData, - void* outputData, - unsigned int dataTypeSize) -{ - const unsigned char* input = reinterpret_cast<const unsigned char*>(inputData); - unsigned char* output = reinterpret_cast<unsigned char*>(outputData); - - const TensorShape inputShape = ExtendShape(inputInfo.GetShape(), 4); - - StridedSliceDescriptor paddedParams = params; - - // Pad parameters to 4 dimensions - PadParams(paddedParams, 4); - - const int start0 = paddedParams.GetStartForAxis(inputShape, 0); - const int stop0 = paddedParams.GetStopForAxis (inputShape, 0, start0); - - const int start1 = paddedParams.GetStartForAxis(inputShape, 1); - const int stop1 = paddedParams.GetStopForAxis (inputShape, 1, start1); - - const int start2 = paddedParams.GetStartForAxis(inputShape, 2); - const int stop2 = paddedParams.GetStopForAxis (inputShape, 2, start2); - - const int start3 = paddedParams.GetStartForAxis(inputShape, 3); - const int stop3 = paddedParams.GetStopForAxis (inputShape, 3, start3); - - const int step = boost::numeric_cast<int>(dataTypeSize); - - for (int in0 = start0; - !LoopCondition(in0, stop0, paddedParams.m_Stride[0]); - in0 += paddedParams.m_Stride[0]) - { - for (int in1 = start1; - !LoopCondition(in1, stop1, paddedParams.m_Stride[1]); - in1 += paddedParams.m_Stride[1]) - { - for (int in2 = start2; - !LoopCondition(in2, stop2, paddedParams.m_Stride[2]); - in2 += paddedParams.m_Stride[2]) - { - for (int in3 = start3; - !LoopCondition(in3, stop3, paddedParams.m_Stride[3]); - in3 += paddedParams.m_Stride[3]) - { - int dim1 = boost::numeric_cast<int>(inputShape[1]); - int dim2 = boost::numeric_cast<int>(inputShape[2]); - int dim3 = boost::numeric_cast<int>(inputShape[3]); - - int inputOffset = (((in0 * dim1 + in1) * dim2 + in2) * dim3 + in3) * step; - ::memcpy(output, input + inputOffset, dataTypeSize); - output += step; - } - } - } - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/StridedSlice.hpp b/src/backends/reference/workloads/StridedSlice.hpp deleted file mode 100644 index b13a8e4e33..0000000000 --- a/src/backends/reference/workloads/StridedSlice.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Descriptors.hpp> -#include <armnn/Tensor.hpp> - -namespace armnn -{ - -void StridedSlice(const TensorInfo& inputInfo, - const StridedSliceDescriptor& params, - const void* inputData, - void* outputData, - unsigned int dataTypeSize); - -} // namespace armnn diff --git a/src/backends/reference/workloads/StringMapping.cpp b/src/backends/reference/workloads/StringMapping.cpp deleted file mode 100644 index 3ca8843812..0000000000 --- a/src/backends/reference/workloads/StringMapping.cpp +++ /dev/null @@ -1,17 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "StringMapping.hpp" - -namespace armnn -{ - -const StringMapping& StringMapping::Instance() -{ - static StringMapping instance; - return instance; -} - -} // armnn diff --git a/src/backends/reference/workloads/StringMapping.hpp b/src/backends/reference/workloads/StringMapping.hpp deleted file mode 100644 index 1654b78088..0000000000 --- a/src/backends/reference/workloads/StringMapping.hpp +++ /dev/null @@ -1,53 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -namespace armnn -{ - -/// -/// StringMapping is helper class to be able to use strings as template -/// parameters, so this allows simplifying code which only differs in -/// a string, such as a debug string literal. -/// -struct StringMapping -{ -public: - enum Id { - RefAdditionWorkload_Execute, - RefDivisionWorkload_Execute, - RefMaximumWorkload_Execute, - RefMinimumWorkload_Execute, - RefMultiplicationWorkload_Execute, - RefSubtractionWorkload_Execute, - MAX_STRING_ID - }; - - const char * Get(Id id) const - { - return m_Strings[id]; - } - - static const StringMapping& Instance(); - -private: - StringMapping() - { - m_Strings[RefAdditionWorkload_Execute] = "RefAdditionWorkload_Execute"; - m_Strings[RefDivisionWorkload_Execute] = "RefDivisionWorkload_Execute"; - m_Strings[RefMaximumWorkload_Execute] = "RefMaximumWorkload_Execute"; - m_Strings[RefMinimumWorkload_Execute] = "RefMinimumWorkload_Execute"; - m_Strings[RefMultiplicationWorkload_Execute] = "RefMultiplicationWorkload_Execute"; - m_Strings[RefSubtractionWorkload_Execute] = "RefSubtractionWorkload_Execute"; - } - - StringMapping(const StringMapping &) = delete; - StringMapping& operator=(const StringMapping &) = delete; - - const char * m_Strings[MAX_STRING_ID]; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/TensorBufferArrayView.hpp b/src/backends/reference/workloads/TensorBufferArrayView.hpp deleted file mode 100644 index e03c42fe60..0000000000 --- a/src/backends/reference/workloads/TensorBufferArrayView.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <armnn/Tensor.hpp> - -#include <armnnUtils/DataLayoutIndexed.hpp> - -#include <boost/assert.hpp> - -namespace armnn -{ - -// Utility class providing access to raw tensor memory based on indices along each dimension. -template <typename DataType> -class TensorBufferArrayView -{ -public: - TensorBufferArrayView(const TensorShape& shape, DataType* data, - armnnUtils::DataLayoutIndexed dataLayout = DataLayout::NCHW) - : m_Shape(shape) - , m_Data(data) - , m_DataLayout(dataLayout) - { - BOOST_ASSERT(m_Shape.GetNumDimensions() == 4); - } - - DataType& Get(unsigned int b, unsigned int c, unsigned int h, unsigned int w) const - { - return m_Data[m_DataLayout.GetIndex(m_Shape, b, c, h, w)]; - } - -private: - const TensorShape m_Shape; - DataType* m_Data; - armnnUtils::DataLayoutIndexed m_DataLayout; -}; - -} //namespace armnn diff --git a/src/backends/reference/workloads/TransposeConvolution2d.cpp b/src/backends/reference/workloads/TransposeConvolution2d.cpp deleted file mode 100644 index 5698014181..0000000000 --- a/src/backends/reference/workloads/TransposeConvolution2d.cpp +++ /dev/null @@ -1,131 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "TransposeConvolution2d.hpp" - -#include <armnnUtils/DataLayoutIndexed.hpp> - -namespace armnn -{ - -using namespace armnnUtils; - -void TransposeConvolution2dImpl(const TransposeConvolution2dDescriptor& descriptor, - const TensorShape& inputShape, - Decoder<float>& inputDecoder, - const TensorShape& outputShape, - Encoder<float>& outputEncoder, - const TensorShape& weightsShape, - Decoder<float>& weightsDecoder, - Decoder<float>* biasesDecoder) -{ - if (descriptor.m_BiasEnabled && !biasesDecoder) - { - throw InvalidArgumentException("Biases enabled but no bias data provided"); - } - const DataLayoutIndexed dataLayoutIndexed(descriptor.m_DataLayout); - const unsigned int channelsIndex = dataLayoutIndexed.GetChannelsIndex(); - const unsigned int heightIndex = dataLayoutIndexed.GetHeightIndex(); - const unsigned int widthIndex = dataLayoutIndexed.GetWidthIndex(); - - unsigned int numBatches = inputShape[0]; - - unsigned int inputWidth = inputShape[widthIndex]; - unsigned int inputHeight = inputShape[heightIndex]; - unsigned int inputDepth = inputShape[channelsIndex]; - - unsigned int weightsHeight = weightsShape[heightIndex]; - unsigned int weightsWidth = weightsShape[widthIndex]; - - unsigned int outputHeight = outputShape[heightIndex]; - unsigned int outputWidth = outputShape[widthIndex]; - unsigned int outputDepth = outputShape[channelsIndex]; - - unsigned int paddingLeft = descriptor.m_PadLeft; - unsigned int paddingTop = descriptor.m_PadTop; - - unsigned int strideX = descriptor.m_StrideX; - unsigned int strideY = descriptor.m_StrideY; - - std::vector<float> outputBuffer(outputShape.GetNumElements(), 0); - - for (unsigned int batch = 0u; batch < numBatches; ++batch) - { - for (unsigned int yInput = 0u; yInput < inputHeight; ++yInput) - { - for (unsigned int xInput = 0u; xInput < inputWidth; ++xInput) - { - unsigned int xOutputOrigin = xInput * strideX - paddingLeft; - unsigned int yOutputOrigin = yInput * strideY - paddingTop; - - for (unsigned int dOutput = 0u; dOutput < outputDepth; ++dOutput) - { - for (unsigned int yWeights = 0u; yWeights < weightsHeight; ++yWeights) - { - for (unsigned int xWeights = 0u; xWeights < weightsWidth; ++xWeights) - { - unsigned int yOutput = yOutputOrigin + yWeights; - unsigned int xOutput = xOutputOrigin + xWeights; - - if (yOutput < outputHeight && xOutput< outputWidth) - { - for (unsigned int dInput = 0u; dInput < inputDepth; dInput++) - { - const unsigned int inputIndex = - dataLayoutIndexed.GetIndex(inputShape, batch, dInput, yInput, xInput); - inputDecoder[inputIndex]; - - const unsigned int weightsIndex = - dataLayoutIndexed.GetIndex(weightsShape, dOutput, dInput, yWeights, xWeights); - weightsDecoder.SetIndex(weightsIndex, dOutput); - - const unsigned int outputIndex = - dataLayoutIndexed.GetIndex(outputShape, batch, dOutput, yOutput, xOutput); - outputEncoder[outputIndex]; - - float output = outputBuffer[outputIndex]; - output += inputDecoder.Get() * weightsDecoder.Get(); - outputBuffer[outputIndex] = output; - } - } - } - } - } - } - } - } - - // Apply bias (if enabled) - if (descriptor.m_BiasEnabled) - { - outputEncoder[0]; - Decoder<float>& rBiasesDecoder = *biasesDecoder; - - for (unsigned int batch = 0u; batch < numBatches; ++batch) - { - for (unsigned int dOutput = 0u; dOutput < outputDepth; ++dOutput) - { - rBiasesDecoder.SetIndex(dOutput, dOutput); - for (unsigned int yOutput = 0u; yOutput < outputHeight; ++yOutput) - { - for (unsigned int xOutput = 0u; xOutput < outputWidth; ++xOutput) - { - const unsigned int outputIndex = - dataLayoutIndexed.GetIndex(outputShape, batch, dOutput, yOutput, xOutput); - outputBuffer[outputIndex] += rBiasesDecoder.Get(); - } - } - } - } - } - outputEncoder[0]; - for (float output : outputBuffer) - { - outputEncoder.Set(output); - ++outputEncoder; - } -} - -} // namespace armnn diff --git a/src/backends/reference/workloads/TransposeConvolution2d.hpp b/src/backends/reference/workloads/TransposeConvolution2d.hpp deleted file mode 100644 index f20f327b38..0000000000 --- a/src/backends/reference/workloads/TransposeConvolution2d.hpp +++ /dev/null @@ -1,26 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Decoders.hpp" -#include "Encoders.hpp" - -#include <armnn/Descriptors.hpp> -#include <armnn/Tensor.hpp> - -namespace armnn -{ - -void TransposeConvolution2dImpl(const TransposeConvolution2dDescriptor& descriptor, - const TensorShape& inputShape, - Decoder<float>& inputDecoder, - const TensorShape& outputShape, - Encoder<float>& outputEncoder, - const TensorShape& weightsShape, - Decoder<float>& weightsDecoder, - Decoder<float>* biasesDecoder); - -} // namespace armnn
\ No newline at end of file |