diff options
Diffstat (limited to 'src/backends')
22 files changed, 528 insertions, 0 deletions
diff --git a/src/backends/backendsCommon/LayerSupportBase.cpp b/src/backends/backendsCommon/LayerSupportBase.cpp index 138d45367e..2753c927d5 100644 --- a/src/backends/backendsCommon/LayerSupportBase.cpp +++ b/src/backends/backendsCommon/LayerSupportBase.cpp @@ -95,6 +95,14 @@ bool LayerSupportBase::IsCastSupported(const TensorInfo&, //input return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported); } +bool LayerSupportBase::IsChannelShuffleSupported(const TensorInfo&, //input + const TensorInfo&, //output + const ChannelShuffleDescriptor&, //descriptor + Optional<std::string &> reasonIfUnsupported) const +{ + return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported); +} + bool LayerSupportBase::IsComparisonSupported(const TensorInfo&, // input0 const TensorInfo&, // input1 const TensorInfo&, // output diff --git a/src/backends/backendsCommon/LayerSupportBase.hpp b/src/backends/backendsCommon/LayerSupportBase.hpp index 533a2c6bdd..cc68a220e2 100644 --- a/src/backends/backendsCommon/LayerSupportBase.hpp +++ b/src/backends/backendsCommon/LayerSupportBase.hpp @@ -51,6 +51,11 @@ public: const TensorInfo& output, Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; + bool IsChannelShuffleSupported(const TensorInfo& input, + const TensorInfo& output, + const ChannelShuffleDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; + bool IsComparisonSupported(const TensorInfo& input0, const TensorInfo& input1, const TensorInfo& output, diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp index d87f858601..a6def847fa 100644 --- a/src/backends/backendsCommon/WorkloadData.cpp +++ b/src/backends/backendsCommon/WorkloadData.cpp @@ -2971,6 +2971,19 @@ void TransposeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output"); } +void ChannelShuffleQueueDescriptor::Validate(const WorkloadInfo &workloadInfo) const +{ + const std::string descriptorName{"TransposeQueueDescriptor"}; + + ValidateNumInputs(workloadInfo, descriptorName, 1); + ValidateNumOutputs(workloadInfo, descriptorName, 1); + + const TensorInfo& inputTensorInfo = workloadInfo.m_InputTensorInfos[0]; + const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0]; + + ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output"); +} + void QLstmQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const { const std::string descriptorName{"QLstmQueueDescriptor"}; diff --git a/src/backends/backendsCommon/WorkloadData.hpp b/src/backends/backendsCommon/WorkloadData.hpp index 78da00be5d..b90c29c1b4 100644 --- a/src/backends/backendsCommon/WorkloadData.hpp +++ b/src/backends/backendsCommon/WorkloadData.hpp @@ -747,4 +747,9 @@ struct UnidirectionalSequenceLstmQueueDescriptor : QueueDescriptorWithParameters void Validate(const WorkloadInfo& workloadInfo) const; }; +struct ChannelShuffleQueueDescriptor : QueueDescriptorWithParameters<ChannelShuffleDescriptor> +{ + void Validate(const WorkloadInfo& workloadInfo) const; +}; + } // namespace armnn diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp index 3f5972dab6..00263eca04 100644 --- a/src/backends/backendsCommon/WorkloadFactory.cpp +++ b/src/backends/backendsCommon/WorkloadFactory.cpp @@ -152,6 +152,21 @@ bool IWorkloadFactory::IsLayerConfigurationSupported(const BackendId& backendId, reason); break; } + case LayerType::ChannelShuffle: + { + auto cLayer = PolymorphicDowncast<const ChannelShuffleLayer*>(&layer); + + const TensorInfo& input = layer.GetInputSlot(0).GetConnection()->GetTensorInfo(); + const TensorInfo& output = layer.GetInputSlot(0).GetConnection()->GetTensorInfo(); + + const ChannelShuffleDescriptor descriptor = cLayer->GetParameters(); + + result = layerSupportObject.IsChannelShuffleSupported(OverrideDataType(input, dataType), + OverrideDataType(output, dataType), + descriptor, + reason); + break; + } case LayerType::Comparison: { auto cLayer = PolymorphicDowncast<const ComparisonLayer*>(&layer); @@ -1501,6 +1516,12 @@ std::unique_ptr<IWorkload> IWorkloadFactory::CreateCast(const CastQueueDescripto return std::unique_ptr<IWorkload>(); } +std::unique_ptr<IWorkload> IWorkloadFactory::CreateChannelShuffle(const ChannelShuffleQueueDescriptor& /*descriptor*/, + const WorkloadInfo& /*info*/) const +{ + return std::unique_ptr<IWorkload>(); +} + std::unique_ptr<IWorkload> IWorkloadFactory::CreateComparison(const ComparisonQueueDescriptor& /*descriptor*/, const WorkloadInfo& /*info*/) const { diff --git a/src/backends/backendsCommon/WorkloadFactory.hpp b/src/backends/backendsCommon/WorkloadFactory.hpp index efb8d99fa0..e84657ea13 100644 --- a/src/backends/backendsCommon/WorkloadFactory.hpp +++ b/src/backends/backendsCommon/WorkloadFactory.hpp @@ -90,6 +90,9 @@ public: virtual std::unique_ptr<IWorkload> CreateCast(const CastQueueDescriptor& descriptor, const WorkloadInfo& Info) const; + virtual std::unique_ptr<IWorkload> CreateChannelShuffle(const ChannelShuffleQueueDescriptor& descriptor, + const WorkloadInfo& info) const; + virtual std::unique_ptr<IWorkload> CreateComparison(const ComparisonQueueDescriptor& descriptor, const WorkloadInfo& Info) const; diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk index 7ebc9975c3..7d3558c804 100644 --- a/src/backends/backendsCommon/common.mk +++ b/src/backends/backendsCommon/common.mk @@ -45,6 +45,7 @@ COMMON_TEST_SOURCES := \ test/layerTests/ArgMinMaxTestImpl.cpp \ test/layerTests/BatchNormalizationTestImpl.cpp \ test/layerTests/CastTestImpl.cpp \ + test/layerTests/ChannelShuffleTestImpl.cpp \ test/layerTests/ComparisonTestImpl.cpp \ test/layerTests/ConcatTestImpl.cpp \ test/layerTests/ConstantTestImpl.cpp \ diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt index c9bc5e74b8..292ec0efd2 100644 --- a/src/backends/backendsCommon/test/CMakeLists.txt +++ b/src/backends/backendsCommon/test/CMakeLists.txt @@ -64,6 +64,8 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/BatchToSpaceNdTestImpl.hpp layerTests/CastTestImpl.cpp layerTests/CastTestImpl.hpp + layerTests/ChannelShuffleTestImpl.cpp + layerTests/ChannelShuffleTestImpl.hpp layerTests/ComparisonTestImpl.cpp layerTests/ComparisonTestImpl.hpp layerTests/ConcatTestImpl.cpp diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp index 21b33d297b..c2d21842f2 100644 --- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp +++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp @@ -620,6 +620,8 @@ DECLARE_LAYER_POLICY_2_PARAM(BatchToSpaceNd) DECLARE_LAYER_POLICY_1_PARAM(Cast) +DECLARE_LAYER_POLICY_2_PARAM(ChannelShuffle) + DECLARE_LAYER_POLICY_2_PARAM(Comparison) DECLARE_LAYER_POLICY_2_PARAM(Concat) diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index 0690637500..9f1fa88b16 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -12,6 +12,7 @@ #include <backendsCommon/test/layerTests/BatchNormalizationTestImpl.hpp> #include <backendsCommon/test/layerTests/BatchToSpaceNdTestImpl.hpp> #include <backendsCommon/test/layerTests/CastTestImpl.hpp> +#include <backendsCommon/test/layerTests/ChannelShuffleTestImpl.hpp> #include <backendsCommon/test/layerTests/ComparisonTestImpl.hpp> #include <backendsCommon/test/layerTests/ConcatTestImpl.hpp> #include <backendsCommon/test/layerTests/ConvertBf16ToFp32TestImpl.hpp> diff --git a/src/backends/backendsCommon/test/layerTests/ChannelShuffleTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ChannelShuffleTestImpl.cpp new file mode 100644 index 0000000000..46ee7d960e --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ChannelShuffleTestImpl.cpp @@ -0,0 +1,269 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ChannelShuffleTestImpl.hpp" + +#include <backendsCommon/test/DataTypeUtils.hpp> +#include <backendsCommon/test/TensorCopyUtils.hpp> +#include <backendsCommon/test/WorkloadTestUtils.hpp> + +namespace +{ + +template<typename T, size_t NumDims> +LayerTestResult<T, NumDims> ChannelShuffleTestImpl( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory, + armnn::ChannelShuffleDescriptor descriptor, + armnn::TensorInfo inputTensorInfo, + armnn::TensorInfo outputTensorInfo, + const std::vector<T>& inputData, + const std::vector<T>& outputExpectedData) +{ + IgnoreUnused(memoryManager); + std::vector<T> actualOutput(outputTensorInfo.GetNumElements()); + + std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo); + std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); + + armnn::ChannelShuffleQueueDescriptor data; + data.m_Parameters = descriptor; + armnn::WorkloadInfo info; + AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get()); + AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); + + std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateChannelShuffle(data, info); + + inputHandle->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle.get(), inputData.data()); + + workload->Execute(); + + CopyDataFromITensorHandle(actualOutput.data(), outputHandle.get()); + + return LayerTestResult<T, NumDims>(actualOutput, + outputExpectedData, + outputHandle->GetShape(), + outputTensorInfo.GetShape()); +} +} // anonymous namespace + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 4> SimpleChannelShuffleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + armnn::TensorInfo inputTensorInfo; + armnn::TensorInfo outputTensorInfo; + + unsigned int inputShape[] = { 1,9,1,1 }; + unsigned int outputShape[] = { 1,9,1,1 }; + + armnn::ChannelShuffleDescriptor descriptor; + descriptor.m_Axis = 1; + descriptor.m_NumGroups = 3; + + inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType); + inputTensorInfo.SetQuantizationScale(1.0f); + outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType); + outputTensorInfo.SetQuantizationScale(1.0f); + + auto input = ConvertToDataType<ArmnnType>( + { + 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f + }, + inputTensorInfo); + auto outputExpected = ConvertToDataType<ArmnnType>( + { + 0.0f, 3.0f, 6.0f, 1.0f, 4.0f, 7.0f, 2.0f, 5.0f, 8.0f + }, + outputTensorInfo); + + return ChannelShuffleTestImpl<T, 4>( + workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + inputTensorInfo, + outputTensorInfo, + input, + outputExpected); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> ChannelShuffle2DTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + armnn::TensorInfo inputTensorInfo; + armnn::TensorInfo outputTensorInfo; + + unsigned int inputShape[] = { 3, 12 }; + unsigned int outputShape[] = { 3, 12 }; + + armnn::ChannelShuffleDescriptor descriptor; + descriptor.m_Axis = 1; + descriptor.m_NumGroups = 3; + + inputTensorInfo = armnn::TensorInfo(2, inputShape, ArmnnType); + inputTensorInfo.SetQuantizationScale(1.0f); + outputTensorInfo = armnn::TensorInfo(2, outputShape, ArmnnType); + outputTensorInfo.SetQuantizationScale(1.0f); + + auto input = ConvertToDataType<ArmnnType>( + { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35 + }, + inputTensorInfo); + + auto outputExpected = ConvertToDataType<ArmnnType>( + { + 0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11, + 12, 16, 20, 13, 17, 21, 14, 18, 22, 15, 19, 23, + 24, 28, 32, 25, 29, 33, 26, 30, 34, 27, 31, 35 + }, + outputTensorInfo); + + return ChannelShuffleTestImpl<T, 2>( + workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + inputTensorInfo, + outputTensorInfo, + input, + outputExpected); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 4> ChannelShuffle4DTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + armnn::TensorInfo inputTensorInfo; + armnn::TensorInfo outputTensorInfo; + + unsigned int inputShape[] = { 2, 9, 1, 2 }; + unsigned int outputShape[] = { 2, 9, 1, 2 }; + + armnn::ChannelShuffleDescriptor descriptor; + descriptor.m_Axis = 1; + descriptor.m_NumGroups = 3; + + inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType); + inputTensorInfo.SetQuantizationScale(1.0f); + outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType); + outputTensorInfo.SetQuantizationScale(1.0f); + + auto input = ConvertToDataType<ArmnnType>( + { + 0.0f, 1.0f, + 2.0f, 3.0f, + 4.0f, 5.0f, + + 6.0f, 7.0f, + 8.0f, 9.0f, + 10.0f, 11.0f, + + 12.0f, 13.0f, + 14.0f, 15.0f, + 16.0f, 17.0f, + + 18.0f, 19.0f, + 20.0f, 21.0f, + 22.0f, 23.0f, + + 24.0f, 25.0f, + 26.0f, 27.0f, + 28.0f, 29.0f, + + 30.0f, 31.0f, + 32.0f, 33.0f, + 34.0f, 35.0f + }, + inputTensorInfo); + + auto outputExpected = ConvertToDataType<ArmnnType>( + { + 0.0f, 1.0f, + 6.0f, 7.0f, + 12.0f, 13.0f, + 2.0f, 3.0f, + 8.0f, 9.0f, + 14.0f, 15.0f, + 4.0f, 5.0f, + 10.0f, 11.0f, + 16.0f, 17.0f, + + 18.0f, 19.0f, + 24.0f, 25.0f, + 30.0f, 31.0f, + 20.0f, 21.0f, + 26.0f, 27.0f, + 32.0f, 33.0f, + 22.0f, 23.0f, + 28.0f, 29.0f, + 34.0f, 35.0f + }, + outputTensorInfo); + + return ChannelShuffleTestImpl<T, 4>( + workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + inputTensorInfo, + outputTensorInfo, + input, + outputExpected); +} + +// +// Explicit template specializations +// + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4> +SimpleChannelShuffleTest<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4> +SimpleChannelShuffleTest<armnn::DataType::QAsymmU8>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ChannelShuffle2DTest<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2> +ChannelShuffle2DTest<armnn::DataType::QAsymmU8>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4> +ChannelShuffle4DTest<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4> +ChannelShuffle4DTest<armnn::DataType::QAsymmU8>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file diff --git a/src/backends/backendsCommon/test/layerTests/ChannelShuffleTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ChannelShuffleTestImpl.hpp new file mode 100644 index 0000000000..3500e72ae7 --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ChannelShuffleTestImpl.hpp @@ -0,0 +1,31 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include "LayerTestResult.hpp" + +#include <ResolveType.hpp> + +#include <armnn/backends/IBackendInternal.hpp> +#include <backendsCommon/WorkloadFactory.hpp> + +template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>> +LayerTestResult<T, 4> SimpleChannelShuffleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>> +LayerTestResult<T, 2> ChannelShuffle2DTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>> +LayerTestResult<T, 4> ChannelShuffle4DTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp index 5eba3e5919..aaf9aa0e7c 100644 --- a/src/backends/reference/RefLayerSupport.cpp +++ b/src/backends/reference/RefLayerSupport.cpp @@ -333,6 +333,39 @@ bool RefLayerSupport::IsCastSupported(const TensorInfo& input, return supported; } +bool RefLayerSupport::IsChannelShuffleSupported(const TensorInfo& input, + const TensorInfo& output, + const ChannelShuffleDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) const +{ + IgnoreUnused(descriptor); + bool supported = true; + + // Define supported output and inputs types. + std::array<DataType, 7> supportedTypes = + { + DataType::BFloat16, + DataType::Float32, + DataType::Float16, + DataType::QAsymmS8, + DataType::QAsymmU8, + DataType::QSymmS8, + DataType::QSymmS16 + }; + + supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, + "Reference ChannelShuffle: input is not a supported type."); + + supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, + "Reference ChannelShuffle: output is not a supported type."); + + supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported, + "Reference ChannelShuffle: input and output types are mismatched."); + + return supported; +} + + bool RefLayerSupport::IsComparisonSupported(const TensorInfo& input0, const TensorInfo& input1, const TensorInfo& output, diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp index a1b4dc7f47..2693dc1779 100644 --- a/src/backends/reference/RefLayerSupport.hpp +++ b/src/backends/reference/RefLayerSupport.hpp @@ -50,6 +50,11 @@ public: const TensorInfo& output, Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; + bool IsChannelShuffleSupported(const TensorInfo& input, + const TensorInfo& output, + const ChannelShuffleDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override; + bool IsComparisonSupported(const TensorInfo& input0, const TensorInfo& input1, const TensorInfo& output, diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp index 16cf17cc79..681b73a748 100644 --- a/src/backends/reference/RefWorkloadFactory.cpp +++ b/src/backends/reference/RefWorkloadFactory.cpp @@ -183,6 +183,12 @@ std::unique_ptr<IWorkload> RefWorkloadFactory::CreateCast(const CastQueueDescrip return std::make_unique<RefCastWorkload>(descriptor, info); } +std::unique_ptr<IWorkload> RefWorkloadFactory::CreateChannelShuffle(const ChannelShuffleQueueDescriptor &descriptor, + const WorkloadInfo &info) const +{ + return std::make_unique<RefChannelShuffleWorkload>(descriptor,info); +} + std::unique_ptr<IWorkload> RefWorkloadFactory::CreateComparison(const ComparisonQueueDescriptor& descriptor, const WorkloadInfo& info) const { diff --git a/src/backends/reference/RefWorkloadFactory.hpp b/src/backends/reference/RefWorkloadFactory.hpp index 113aca70ef..fe3eb54795 100644 --- a/src/backends/reference/RefWorkloadFactory.hpp +++ b/src/backends/reference/RefWorkloadFactory.hpp @@ -88,6 +88,9 @@ public: std::unique_ptr<IWorkload> CreateCast(const CastQueueDescriptor& descriptor, const WorkloadInfo& info) const override; + std::unique_ptr<IWorkload> CreateChannelShuffle(const ChannelShuffleQueueDescriptor& descriptor, + const WorkloadInfo& info) const override; + std::unique_ptr<IWorkload> CreateComparison(const ComparisonQueueDescriptor& descriptor, const WorkloadInfo& info) const override; diff --git a/src/backends/reference/backend.mk b/src/backends/reference/backend.mk index 17ddbe0df1..2dc2bc4919 100644 --- a/src/backends/reference/backend.mk +++ b/src/backends/reference/backend.mk @@ -49,6 +49,7 @@ BACKEND_SOURCES := \ workloads/RefBatchNormalizationWorkload.cpp \ workloads/RefBatchToSpaceNdWorkload.cpp \ workloads/RefCastWorkload.cpp \ + workloads/RefChannelShuffleWorkload.cpp \ workloads/RefComparisonWorkload.cpp \ workloads/RefConcatWorkload.cpp \ workloads/RefConstantWorkload.cpp \ diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp index 18490e29c7..b0855151de 100644 --- a/src/backends/reference/test/RefLayerTests.cpp +++ b/src/backends/reference/test/RefLayerTests.cpp @@ -1398,6 +1398,13 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeQuantisedSymm16, SimpleReshapeTest<Da ARMNN_AUTO_TEST_CASE_WITH_THF(Reshape5d, Reshape5dTest<DataType::Float32>) ARMNN_AUTO_TEST_CASE_WITH_THF(ReshapeBoolean, ReshapeBooleanTest) +// ChannelShuffle +ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleChannelShuffleFloat32, SimpleChannelShuffleTest<DataType::Float32>) +ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleChannelShuffleQAsymmU8, SimpleChannelShuffleTest<DataType::QAsymmU8>) +ARMNN_AUTO_TEST_CASE_WITH_THF(ChannelShuffle2DFloat32, ChannelShuffle2DTest<DataType::Float32>) +ARMNN_AUTO_TEST_CASE_WITH_THF(ChannelShuffle2DQAsymmU8, ChannelShuffle2DTest<DataType::QAsymmU8>) +ARMNN_AUTO_TEST_CASE_WITH_THF(ChannelShuffle4DFloat32, ChannelShuffle4DTest<DataType::Float32>) +ARMNN_AUTO_TEST_CASE_WITH_THF(ChannelShuffle4DQAsymmU8, ChannelShuffle4DTest<DataType::QAsymmU8>) // Rsqrt ARMNN_AUTO_TEST_CASE_WITH_THF(Rsqrt2d, Rsqrt2dTest<DataType::Float32>) diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt index b9f477cb6d..0ab8c6b0bb 100644 --- a/src/backends/reference/workloads/CMakeLists.txt +++ b/src/backends/reference/workloads/CMakeLists.txt @@ -68,6 +68,9 @@ list(APPEND armnnRefBackendWorkloads_sources RefBatchToSpaceNdWorkload.hpp RefCastWorkload.cpp RefCastWorkload.hpp + RefChannelShuffleWorkload.cpp + RefChannelShuffleWorkload.hpp + RefShapeWorkload.hpp RefComparisonWorkload.cpp RefComparisonWorkload.hpp RefConcatWorkload.cpp diff --git a/src/backends/reference/workloads/RefChannelShuffleWorkload.cpp b/src/backends/reference/workloads/RefChannelShuffleWorkload.cpp new file mode 100644 index 0000000000..6571715c63 --- /dev/null +++ b/src/backends/reference/workloads/RefChannelShuffleWorkload.cpp @@ -0,0 +1,83 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include <backendsCommon/test/DataTypeUtils.hpp> +#include <armnn/backends/ITensorHandleFactory.hpp> +#include <armnnUtils/Transpose.hpp> +#include "RefChannelShuffleWorkload.hpp" +#include "RefWorkloadUtils.hpp" +#include "Profiling.hpp" +#include "Decoders.hpp" +#include "Encoders.hpp" + +namespace armnn +{ +void RefChannelShuffleWorkload::Execute() const +{ + Execute(m_Data.m_Inputs, m_Data.m_Outputs); +} + +void RefChannelShuffleWorkload::ExecuteAsync(WorkingMemDescriptor &workingMemDescriptor) +{ + Execute(workingMemDescriptor.m_Inputs, workingMemDescriptor.m_Outputs); +} + +// Reference implementation for channel shuffle taken from +// https://android.googlesource.com/platform/frameworks/ml/+/refs/heads/master/nn/common/operations/ChannelShuffle.cpp +void RefChannelShuffleWorkload::Execute(std::vector<ITensorHandle*> inputs, + std::vector<ITensorHandle*> outputs) const +{ + ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefChannelShuffleWorkload_Execute"); + + const TensorInfo& inputInfo = GetTensorInfo(inputs[0]); + const TensorInfo& outputInfo = GetTensorInfo(outputs[0]); + std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputInfo, inputs[0]->Map()); + Decoder<float>& decoder = *decoderPtr; + + std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputInfo, outputs[0]->Map()); + Encoder<float>& encoder = *encoderPtr; + + auto getNumberOfElements = [](const TensorShape& tensorShape,uint32_t startAxis, uint32_t lastAxis) + { + uint32_t count = 1; + for (uint32_t i = startAxis; i < lastAxis; i++) + { + count *= tensorShape[i]; + } + return count; + }; + const TensorShape tensorShape = GetTensorInfo(inputs[0]).GetShape(); + uint32_t channelsAxis = m_Data.m_Parameters.m_Axis; // channelsAxis to perform channel shuffle on + + const uint32_t numGroups = m_Data.m_Parameters.m_NumGroups; + const uint32_t groupSize = tensorShape[channelsAxis] / numGroups; + + uint32_t outerSize = getNumberOfElements(tensorShape, 0, channelsAxis); + uint32_t innerSize = getNumberOfElements(tensorShape, channelsAxis + 1, tensorShape.GetNumDimensions()); + + for (uint32_t outer = 0; outer < outerSize; ++outer) + { + for (uint32_t inner = 0; inner < innerSize; ++inner) + { + uint32_t decoderStep1 = outer * tensorShape[channelsAxis] * innerSize + inner; + decoder += decoderStep1; + uint32_t encoderStep1 = outer * tensorShape[channelsAxis] * innerSize + inner; + encoder += encoderStep1; + for (uint32_t i = 0; i < groupSize; i++) + { + for (uint32_t j = 0; j < numGroups; j++, encoder += innerSize, encoderStep1 += innerSize) + { + decoder += innerSize * (i + j * groupSize); + float decoded = decoder.Get(); + encoder.Set(decoded); + decoder -= innerSize * (i + j * groupSize); + } + } + decoder -= decoderStep1; + encoder -= encoderStep1; + } + } +} +}
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefChannelShuffleWorkload.hpp b/src/backends/reference/workloads/RefChannelShuffleWorkload.hpp new file mode 100644 index 0000000000..0e4c4546fc --- /dev/null +++ b/src/backends/reference/workloads/RefChannelShuffleWorkload.hpp @@ -0,0 +1,25 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include <backendsCommon/Workload.hpp> +#include <backendsCommon/WorkloadData.hpp> + +namespace armnn +{ + +class RefChannelShuffleWorkload : public BaseWorkload<ChannelShuffleQueueDescriptor> +{ +public: + using BaseWorkload<ChannelShuffleQueueDescriptor>::BaseWorkload; + void Execute() const override; + void ExecuteAsync(WorkingMemDescriptor& workingMemDescriptor) override; + +private: + void Execute(std::vector<ITensorHandle*> inputs, std::vector<ITensorHandle*> outputs) const; +}; + +} // namespace armnn
\ No newline at end of file diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp index d3ae58ea15..1cf84eed9e 100644 --- a/src/backends/reference/workloads/RefWorkloads.hpp +++ b/src/backends/reference/workloads/RefWorkloads.hpp @@ -19,6 +19,7 @@ #include "RefBatchNormalizationWorkload.hpp" #include "RefBatchToSpaceNdWorkload.hpp" #include "RefCastWorkload.hpp" +#include "RefChannelShuffleWorkload.hpp" #include "RefComparisonWorkload.hpp" #include "RefConvolution2dWorkload.hpp" #include "RefConstantWorkload.hpp" |