From 3bc00ec1aae17d8bec1c31495141438ffee88dd8 Mon Sep 17 00:00:00 2001 From: Aron Virginas-Tar Date: Fri, 18 Oct 2019 15:42:58 +0100 Subject: IVGCVSW-3999 Add unit tests for new comparison operations * Refactored existing tests for Equal and Greater and moved them to ComparisonTestImpl.cpp * Removed EqualTestImpl.cpp and GreaterTestImpl.cpp * Added new unit tests for GreaterOrEqual, Less, LessOrEqual and NotEqual Signed-off-by: Aron Virginas-Tar Change-Id: I25013200beb1acb88e83b813c5382cb277c74cd7 --- src/backends/backendsCommon/common.mk | 3 +- src/backends/backendsCommon/test/CMakeLists.txt | 5 +- src/backends/backendsCommon/test/LayerTests.hpp | 3 +- .../test/layerTests/ComparisonTestImpl.cpp | 935 +++++++++++++++++++++ .../test/layerTests/ComparisonTestImpl.hpp | 335 +++++--- .../test/layerTests/EqualTestImpl.cpp | 265 ------ .../test/layerTests/EqualTestImpl.hpp | 46 - .../test/layerTests/GreaterTestImpl.cpp | 314 ------- .../test/layerTests/GreaterTestImpl.hpp | 46 - src/backends/cl/test/ClLayerTests.cpp | 9 +- src/backends/neon/test/NeonLayerTests.cpp | 9 +- src/backends/reference/test/RefLayerTests.cpp | 82 +- 12 files changed, 1238 insertions(+), 814 deletions(-) create mode 100644 src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.cpp delete mode 100644 src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp delete mode 100644 src/backends/backendsCommon/test/layerTests/EqualTestImpl.hpp delete mode 100644 src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp delete mode 100644 src/backends/backendsCommon/test/layerTests/GreaterTestImpl.hpp diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk index 8b45b3766f..5024f1efbb 100644 --- a/src/backends/backendsCommon/common.mk +++ b/src/backends/backendsCommon/common.mk @@ -42,6 +42,7 @@ COMMON_TEST_SOURCES := \ test/layerTests/AdditionTestImpl.cpp \ test/layerTests/ArgMinMaxTestImpl.cpp \ test/layerTests/BatchNormalizationTestImpl.cpp \ + test/layerTests/ComparisonTestImpl.cpp \ test/layerTests/ConcatTestImpl.cpp \ test/layerTests/ConstantTestImpl.cpp \ test/layerTests/Conv2dTestImpl.cpp \ @@ -51,12 +52,10 @@ COMMON_TEST_SOURCES := \ test/layerTests/DepthToSpaceTestImpl.cpp \ test/layerTests/DequantizeTestImpl.cpp \ test/layerTests/DivisionTestImpl.cpp \ - test/layerTests/EqualTestImpl.cpp \ test/layerTests/FakeQuantizationTestImpl.cpp \ test/layerTests/FloorTestImpl.cpp \ test/layerTests/FullyConnectedTestImpl.cpp \ test/layerTests/GatherTestImpl.cpp \ - test/layerTests/GreaterTestImpl.cpp \ test/layerTests/InstanceNormalizationTestImpl.cpp \ test/layerTests/L2NormalizationTestImpl.cpp \ test/layerTests/LogSoftmaxTestImpl.cpp \ diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt index 7449e69dcd..8a96318d8f 100644 --- a/src/backends/backendsCommon/test/CMakeLists.txt +++ b/src/backends/backendsCommon/test/CMakeLists.txt @@ -59,6 +59,7 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/BatchNormalizationTestImpl.cpp layerTests/BatchNormalizationTestImpl.hpp layerTests/BatchToSpaceNdTestImpl.hpp + layerTests/ComparisonTestImpl.cpp layerTests/ComparisonTestImpl.hpp layerTests/ConcatTestImpl.cpp layerTests/ConcatTestImpl.hpp @@ -80,8 +81,6 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/DivisionTestImpl.cpp layerTests/DivisionTestImpl.hpp layerTests/ElementwiseTestImpl.hpp - layerTests/EqualTestImpl.cpp - layerTests/EqualTestImpl.hpp layerTests/FakeQuantizationTestImpl.cpp layerTests/FakeQuantizationTestImpl.hpp layerTests/FloorTestImpl.cpp @@ -90,8 +89,6 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/FullyConnectedTestImpl.hpp layerTests/GatherTestImpl.cpp layerTests/GatherTestImpl.hpp - layerTests/GreaterTestImpl.cpp - layerTests/GreaterTestImpl.hpp layerTests/InstanceNormalizationTestImpl.cpp layerTests/InstanceNormalizationTestImpl.hpp layerTests/L2NormalizationTestImpl.cpp diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index eb413140da..05c307ead2 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -21,12 +22,10 @@ #include #include #include -#include #include #include #include #include -#include #include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.cpp new file mode 100644 index 0000000000..9da1d425d9 --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.cpp @@ -0,0 +1,935 @@ +// +// Copyright © 2019 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ComparisonTestImpl.hpp" + +#include + +#include +#include + +#include +#include + +#include +#include +#include + +#include + +#include + +namespace +{ + +template > +LayerTestResult ComparisonTestImpl( + armnn::IWorkloadFactory & workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager, + const armnn::ComparisonDescriptor& descriptor, + const armnn::TensorShape& shape0, + std::vector values0, + float quantScale0, + int quantOffset0, + const armnn::TensorShape& shape1, + std::vector values1, + float quantScale1, + int quantOffset1, + const armnn::TensorShape& outShape, + std::vector outValues, + float outQuantScale, + int outQuantOffset) +{ + BOOST_ASSERT(shape0.GetNumDimensions() == NumDims); + armnn::TensorInfo inputTensorInfo0(shape0, ArmnnInType, quantScale0, quantOffset0); + + BOOST_ASSERT(shape1.GetNumDimensions() == NumDims); + armnn::TensorInfo inputTensorInfo1(shape1, ArmnnInType, quantScale1, quantOffset1); + + BOOST_ASSERT(outShape.GetNumDimensions() == NumDims); + armnn::TensorInfo outputTensorInfo(outShape, armnn::DataType::Boolean, outQuantScale, outQuantOffset); + + auto input0 = MakeTensor(inputTensorInfo0, values0); + auto input1 = MakeTensor(inputTensorInfo1, values1); + + LayerTestResult ret(outputTensorInfo); + + std::unique_ptr inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0); + std::unique_ptr inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1); + std::unique_ptr outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo); + + armnn::ComparisonQueueDescriptor qDescriptor; + qDescriptor.m_Parameters = descriptor; + + armnn::WorkloadInfo info; + AddInputToWorkload(qDescriptor, info, inputTensorInfo0, inputHandle0.get()); + AddInputToWorkload(qDescriptor, info, inputTensorInfo1, inputHandle1.get()); + AddOutputToWorkload(qDescriptor, info, outputTensorInfo, outputHandle.get()); + + std::unique_ptr workload = workloadFactory.CreateComparison(qDescriptor, info); + + inputHandle0->Allocate(); + inputHandle1->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle0.get(), input0.origin()); + CopyDataToITensorHandle(inputHandle1.get(), input1.origin()); + + workload->PostAllocationConfigure(); + ExecuteWorkload(*workload, memoryManager); + + CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get()); + + ret.outputExpected = MakeTensor(outputTensorInfo, outValues); + ret.compareBoolean = true; + + return ret; +} + +template > +LayerTestResult ComparisonTestImpl( + armnn::IWorkloadFactory & workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager, + const armnn::ComparisonDescriptor& descriptor, + const armnn::TensorShape& shape0, + std::vector values0, + const armnn::TensorShape& shape1, + std::vector values1, + const armnn::TensorShape outShape, + std::vector outValues, + float quantScale = 1.f, + int quantOffset = 0) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + descriptor, + shape0, + values0, + quantScale, + quantOffset, + shape1, + values1, + quantScale, + quantOffset, + outShape, + outValues, + quantScale, + quantOffset); +} + +template +std::vector GetExpectedOutputData(const TestData& testData, armnn::ComparisonOperation operation) +{ + switch (operation) + { + case armnn::ComparisonOperation::Equal: + return testData.m_OutputEqual; + case armnn::ComparisonOperation::Greater: + return testData.m_OutputGreater; + case armnn::ComparisonOperation::GreaterOrEqual: + return testData.m_OutputGreaterOrEqual; + case armnn::ComparisonOperation::Less: + return testData.m_OutputLess; + case armnn::ComparisonOperation::LessOrEqual: + return testData.m_OutputLessOrEqual; + case armnn::ComparisonOperation::NotEqual: + default: + return testData.m_OutputNotEqual; + } +} + +template +LayerTestResult ComparisonTestImpl(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const TestData& testData, + armnn::ComparisonOperation operation, + float quantScale = 1.f, + int quantOffset = 0) +{ + using T = armnn::ResolveType; + + std::vector inputData0 = QuantizedVector(quantScale, quantOffset, testData.m_InputData0); + std::vector inputData1 = QuantizedVector(quantScale, quantOffset, testData.m_InputData1); + + return ComparisonTestImpl<4, ArmnnInType>( + workloadFactory, + memoryManager, + armnn::ComparisonDescriptor(operation), + testData.m_InputShape0, + inputData0, + testData.m_InputShape1, + inputData1, + testData.m_OutputShape, + GetExpectedOutputData(testData, operation), + quantScale, + quantOffset); +} + +class ComparisonTestData +{ +public: + ComparisonTestData() = default; + virtual ~ComparisonTestData() = default; + + armnn::TensorShape m_InputShape0; + armnn::TensorShape m_InputShape1; + armnn::TensorShape m_OutputShape; + + std::vector m_InputData0; + std::vector m_InputData1; + + std::vector m_OutputEqual; + std::vector m_OutputGreater; + std::vector m_OutputGreaterOrEqual; + std::vector m_OutputLess; + std::vector m_OutputLessOrEqual; + std::vector m_OutputNotEqual; +}; + +class SimpleTestData : public ComparisonTestData +{ +public: + SimpleTestData() : ComparisonTestData() + { + m_InputShape0 = { 2, 2, 2, 2 }; + + m_InputShape1 = m_InputShape0; + m_OutputShape = m_InputShape0; + + m_InputData0 = + { + 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 + }; + + m_InputData1 = + { + 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f, + 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f + }; + + m_OutputEqual = + { + 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 1 + }; + + m_OutputGreater = + { + 0, 0, 0, 0, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0 + }; + + m_OutputGreaterOrEqual = + { + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 1, 1, 1, 1 + }; + + m_OutputLess = + { + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0 + }; + + m_OutputLessOrEqual = + { + 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1 + }; + + m_OutputNotEqual = + { + 0, 0, 0, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 0, 0, 0 + }; + } +}; + +class Broadcast1ElementTestData : public ComparisonTestData +{ +public: + Broadcast1ElementTestData() : ComparisonTestData() + { + m_InputShape0 = { 1, 2, 2, 2 }; + m_InputShape1 = { 1, 1, 1, 1 }; + + m_OutputShape = m_InputShape0; + + m_InputData0 = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f }; + m_InputData1 = { 3.f }; + + m_OutputEqual = { 0, 0, 1, 0, 0, 0, 0, 0 }; + m_OutputGreater = { 0, 0, 0, 1, 1, 1, 1, 1 }; + m_OutputGreaterOrEqual = { 0, 0, 1, 1, 1, 1, 1, 1 }; + m_OutputLess = { 1, 1, 0, 0, 0, 0, 0, 0 }; + m_OutputLessOrEqual = { 1, 1, 1, 0, 0, 0, 0, 0 }; + m_OutputNotEqual = { 1, 1, 0, 1, 1, 1, 1, 1 }; + } +}; + +class Broadcast1dVectorTestData : public ComparisonTestData +{ +public: + Broadcast1dVectorTestData() : ComparisonTestData() + { + m_InputShape0 = { 1, 2, 2, 3 }; + m_InputShape1 = { 1, 1, 1, 3 }; + + m_OutputShape = m_InputShape0; + + m_InputData0 = + { + 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, + 7.f, 8.f, 9.f, 10.f, 11.f, 12.f + }; + + m_InputData1 = { 4.f, 5.f, 6.f }; + + m_OutputEqual = + { + 0, 0, 0, 1, 1, 1, + 0, 0, 0, 0, 0, 0 + }; + + m_OutputGreater = + { + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1 + }; + + m_OutputGreaterOrEqual = + { + 0, 0, 0, 1, 1, 1, + 1, 1, 1, 1, 1, 1 + }; + + m_OutputLess = + { + 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0 + }; + + m_OutputLessOrEqual = + { + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0 + }; + + m_OutputNotEqual = + { + 1, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1 + }; + } +}; + +static SimpleTestData s_SimpleTestData; +static Broadcast1ElementTestData s_Broadcast1ElementTestData; +static Broadcast1dVectorTestData s_Broadcast1dVectorTestData; + +} // anonymous namespace + +// Equal +LayerTestResult EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Equal); +} + +LayerTestResult EqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Equal); +} + +// Greater +LayerTestResult GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Greater); +} + +LayerTestResult GreaterBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Greater); +} + +// GreaterOrEqual +LayerTestResult GreaterOrEqualSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +LayerTestResult GreaterOrEqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::GreaterOrEqual); +} + +// Less +LayerTestResult LessSimpleTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::Less); +} + +LayerTestResult LessBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::Less); +} + +// LessOrEqual +LayerTestResult LessOrEqualSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +LayerTestResult LessOrEqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::LessOrEqual); +} + +// NotEqual +LayerTestResult NotEqualSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_SimpleTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1ElementTestData, + armnn::ComparisonOperation::NotEqual); +} + +LayerTestResult NotEqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + return ComparisonTestImpl( + workloadFactory, + memoryManager, + s_Broadcast1dVectorTestData, + armnn::ComparisonOperation::NotEqual); +} diff --git a/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp index 6ce9b306c0..84928faea0 100644 --- a/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp +++ b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp @@ -7,120 +7,227 @@ #include "LayerTestResult.hpp" -#include - -#include - #include -#include -#include #include -#include -#include - -#include - -template > -LayerTestResult ComparisonTestImpl( - armnn::IWorkloadFactory & workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager, - const armnn::ComparisonDescriptor& descriptor, - const unsigned int shape0[NumDims], - std::vector values0, - float quantScale0, - int quantOffset0, - const unsigned int shape1[NumDims], - std::vector values1, - float quantScale1, - int quantOffset1, - const unsigned int outShape[NumDims], - std::vector outValues, - float outQuantScale, - int outQuantOffset) -{ - armnn::TensorInfo inputTensorInfo0{NumDims, shape0, ArmnnInType}; - armnn::TensorInfo inputTensorInfo1{NumDims, shape1, ArmnnInType}; - armnn::TensorInfo outputTensorInfo{NumDims, outShape, armnn::DataType::Boolean}; - - auto input0 = MakeTensor(inputTensorInfo0, values0); - auto input1 = MakeTensor(inputTensorInfo1, values1); - - inputTensorInfo0.SetQuantizationScale(quantScale0); - inputTensorInfo0.SetQuantizationOffset(quantOffset0); - - inputTensorInfo1.SetQuantizationScale(quantScale1); - inputTensorInfo1.SetQuantizationOffset(quantOffset1); - - outputTensorInfo.SetQuantizationScale(outQuantScale); - outputTensorInfo.SetQuantizationOffset(outQuantOffset); - - LayerTestResult ret(outputTensorInfo); - - std::unique_ptr inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0); - std::unique_ptr inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1); - std::unique_ptr outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo); - - armnn::ComparisonQueueDescriptor qDescriptor; - qDescriptor.m_Parameters = descriptor; - - armnn::WorkloadInfo info; - AddInputToWorkload(qDescriptor, info, inputTensorInfo0, inputHandle0.get()); - AddInputToWorkload(qDescriptor, info, inputTensorInfo1, inputHandle1.get()); - AddOutputToWorkload(qDescriptor, info, outputTensorInfo, outputHandle.get()); - - std::unique_ptr workload = workloadFactory.CreateComparison(qDescriptor, info); - - inputHandle0->Allocate(); - inputHandle1->Allocate(); - outputHandle->Allocate(); - - CopyDataToITensorHandle(inputHandle0.get(), input0.origin()); - CopyDataToITensorHandle(inputHandle1.get(), input1.origin()); - - workload->PostAllocationConfigure(); - ExecuteWorkload(*workload, memoryManager); - - CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get()); - - ret.outputExpected = MakeTensor(outputTensorInfo, outValues); - ret.compareBoolean = true; - - return ret; -} - -template > -LayerTestResult ComparisonTestImpl( - armnn::IWorkloadFactory & workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager, - const armnn::ComparisonDescriptor& descriptor, - const unsigned int shape0[NumDims], - std::vector values0, - const unsigned int shape1[NumDims], - std::vector values1, - const unsigned int outShape[NumDims], - std::vector outValues, - float qScale = 10.f, - int qOffset = 0) -{ - return ComparisonTestImpl( - workloadFactory, - memoryManager, - descriptor, - shape0, - values0, - qScale, - qOffset, - shape1, - values1, - qScale, - qOffset, - outShape, - outValues, - qScale, - qOffset); -} +// Equal +LayerTestResult EqualSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult EqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +// Greater +LayerTestResult GreaterSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +// GreaterOrEqual +LayerTestResult GreaterOrEqualSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult GreaterOrEqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +// Less +LayerTestResult LessSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +// LessOrEqual +LayerTestResult LessOrEqualSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LessOrEqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +// NotEqual +LayerTestResult NotEqualSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualBroadcast1dVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualSimpleFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualBroadcast1ElementFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualBroadcast1dVectorFloat16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualSimpleUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult NotEqualBroadcast1dVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); diff --git a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp deleted file mode 100644 index a3d2b2796f..0000000000 --- a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp +++ /dev/null @@ -1,265 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "EqualTestImpl.hpp" - -#include "ComparisonTestImpl.hpp" - -#include - -LayerTestResult EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int width = 2u; - const unsigned int height = 2u; - const unsigned int channelCount = 2u; - const unsigned int batchSize = 2u; - - unsigned int shape[] = { batchSize, channelCount, height, width }; - - std::vector input0 = - { - 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 - }; - - std::vector input1({ 1, 1, 1, 1, 3, 3, 3, 3, - 5, 5, 5, 5, 4, 4, 4, 4 }); - - std::vector output({ 1, 1, 1, 1, 0, 0, 0, 0, - 0, 0, 0, 0, 1, 1, 1, 1 }); - - return ComparisonTestImpl<4, armnn::DataType::Float32>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape, - input0, - shape, - input1, - shape, - output); -} - -LayerTestResult EqualBroadcast1ElementTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - unsigned int shape0[] = { 1, 2, 2, 2 }; - std::vector input0({ 1, 2, 3, 4, 5, 6, 7, 8}); - - unsigned int shape1[] = { 1, 1, 1, 1 }; - std::vector input1({ 1 }); - - std::vector output({ 1, 0, 0, 0, 0, 0, 0, 0}); - - return ComparisonTestImpl<4, armnn::DataType::Float32>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult EqualBroadcast1DVectorTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 3 }; - - std::vector input0({ 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12 }); - - std::vector input1({ 1, 2, 3}); - - std::vector output({ 1, 1, 1, 0, 0, 0, - 0, 0, 0, 0, 0, 0 }); - - return ComparisonTestImpl<4, armnn::DataType::Float32>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult EqualFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - using namespace half_float::literal; - - unsigned int shape[] = { 2, 2, 2, 2 }; - - // See dequantized values to the right. - std::vector input0({ 1._h, 1._h, 1._h, 1._h, 6._h, 6._h, 6._h, 6._h, - 3._h, 3._h, 3._h, 3._h, 7._h, 7._h, 7._h, 7._h }); - - std::vector input1({ 2._h, 2._h, 2._h, 2._h, 6._h, 6._h, 6._h, 6._h, - 3._h, 3._h, 3._h, 3._h, 5._h, 5._h, 5._h, 5._h }); - - std::vector output({ 0, 0, 0, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 0, 0, 0, 0 }); - - return ComparisonTestImpl<4, armnn::DataType::Float16>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape, - input0, - shape, - input1, - shape, - output); -} - -LayerTestResult EqualBroadcast1ElementFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - using namespace half_float::literal; - - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 1 }; - - std::vector input0({ 1._h, 2._h, 3._h, 4._h, 5._h, 6._h, - 7._h, 8._h, 9._h, 10._h, 11._h, 12._h }); - - std::vector input1({ 1._h }); - - std::vector output({ 1, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0 }); - - return ComparisonTestImpl<4, armnn::DataType::Float16>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult EqualBroadcast1DVectorFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - using namespace half_float::literal; - - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 3 }; - - std::vector input0({ 1._h, 2._h, 3._h, 4._h, 5._h, 6._h, - 7._h, 8._h, 9._h, 10._h, 11._h, 12._h }); - - std::vector input1({ 1._h, 1._h, 3._h }); - - std::vector output({ 1, 0, 1, 0, 0, 0, - 0, 0, 0, 0, 0, 0 }); - - return ComparisonTestImpl<4, armnn::DataType::Float16>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult EqualUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - unsigned int shape[] = { 2, 2, 2, 2 }; - - // See dequantized values to the right. - std::vector input0({ 1, 1, 1, 1, 6, 6, 6, 6, - 3, 3, 3, 3, 7, 7, 7, 7 }); - - std::vector input1({ 2, 2, 2, 2, 6, 6, 6, 6, - 3, 3, 3, 3, 5, 5, 5, 5 }); - - std::vector output({ 0, 0, 0, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 0, 0, 0, 0 }); - - return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape, - input0, - shape, - input1, - shape, - output); -} - -LayerTestResult EqualBroadcast1ElementUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 1 }; - - std::vector input0({ 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12 }); - - std::vector input1({ 1 }); - - std::vector output({ 1, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0 }); - - return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult EqualBroadcast1DVectorUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 3 }; - - std::vector input0({ 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12 }); - - std::vector input1({ 1, 1, 3}); - - std::vector output({ 1, 0, 1, 0, 0, 0, - 0, 0, 0, 0, 0, 0 }); - - return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal), - shape0, - input0, - shape1, - input1, - shape0, - output); -} diff --git a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/EqualTestImpl.hpp deleted file mode 100644 index 3ff07ba58f..0000000000 --- a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "LayerTestResult.hpp" - -#include -#include - -LayerTestResult EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualBroadcast1ElementTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualBroadcast1DVectorTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualBroadcast1ElementFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualBroadcast1DVectorFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualBroadcast1ElementUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult EqualBroadcast1DVectorUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); diff --git a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp deleted file mode 100644 index 271bc235a9..0000000000 --- a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp +++ /dev/null @@ -1,314 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "GreaterTestImpl.hpp" - -#include "ComparisonTestImpl.hpp" - -#include - -LayerTestResult GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int width = 2u; - const unsigned int height = 2u; - const unsigned int channelCount = 2u; - const unsigned int batchSize = 2u; - - unsigned int shape[] = { batchSize, channelCount, height, width }; - - std::vector input0 = - { - 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 - }; - - std::vector input1 = - { - 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f, - 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f - }; - - std::vector output = - { - 0, 0, 0, 0, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0 - }; - - return ComparisonTestImpl<4, armnn::DataType::Float32>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape, - input0, - shape, - input1, - shape, - output); -} - -LayerTestResult GreaterBroadcast1ElementTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - unsigned int shape0[] = { 1, 2, 2, 2 }; - unsigned int shape1[] = { 1, 1, 1, 1 }; - - std::vector input0 = { 1, 2, 3, 4, 5, 6, 7, 8}; - std::vector input1 = { 1 }; - - std::vector output = { 0, 1, 1, 1, 1, 1, 1, 1}; - - return ComparisonTestImpl<4, armnn::DataType::Float32>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult GreaterBroadcast1DVectorTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 3 }; - - std::vector input0 = - { - 1.0f, 2.9f, 2.1f, 4.0f, 5.0f, 6.0f, - 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f - }; - - std::vector input1 = { 1.f, 3.f, 2.f }; - - std::vector output = - { - 0, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1 - }; - - return ComparisonTestImpl<4, armnn::DataType::Float32>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult GreaterFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - using namespace half_float::literal; - - const unsigned int width = 2u; - const unsigned int height = 2u; - const unsigned int channelCount = 2u; - const unsigned int batchSize = 2u; - - unsigned int shape[] = { batchSize, channelCount, height, width }; - - std::vector input0 = - { - 1._h, 1._h, 1._h, 1._h, 5._h, 5._h, 5._h, 5._h, - 3._h, 3._h, 3._h, 3._h, 4._h, 4._h, 4._h, 4._h - }; - - std::vector input1 = - { - 1._h, 1._h, 1._h, 1._h, 3._h, 3._h, 3._h, 3._h, - 5._h, 5._h, 5._h, 5._h, 4._h, 4._h, 4._h, 4._h - }; - - std::vector output = - { - 0, 0, 0, 0, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0 - }; - - return ComparisonTestImpl<4,armnn::DataType::Float16>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape, - input0, - shape, - input1, - shape, - output); -} - -LayerTestResult GreaterBroadcast1ElementFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - using namespace half_float::literal; - - unsigned int shape0[] = { 1, 2, 2, 2 }; - unsigned int shape1[] = { 1, 1, 1, 1 }; - - std::vector input0 = { 1._h, 2._h, 3._h, 4._h, 5._h, 6._h, 7._h, 8._h }; - std::vector input1 = { 1._h }; - - std::vector output = { 0, 1, 1, 1, 1, 1, 1, 1}; - - return ComparisonTestImpl<4, armnn::DataType::Float16>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult GreaterBroadcast1DVectorFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - using namespace half_float::literal; - - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 3 }; - - std::vector input0 = - { - 1.0_h, 2.9_h, 2.1_h, 4.0_h, 5.0_h, 6.0_h, - 7.0_h, 8.0_h, 9.0_h, 10.0_h, 11.0_h, 12.0_h - }; - - std::vector input1 = { 1._h, 3._h, 2._h }; - - std::vector output = - { - 0, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1 - }; - - return ComparisonTestImpl<4, armnn::DataType::Float16>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult GreaterUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - unsigned int shape[] = { 2, 2, 2, 2 }; - - // See dequantized values to the right. - std::vector input0 = - { - 1, 1, 1, 1, 6, 6, 6, 6, - 3, 3, 3, 3, 5, 5, 5, 5 - }; - - std::vector input1 = - { - 2, 2, 2, 2, 6, 6, 6, 6, - 2, 2, 2, 2, 5, 5, 5, 5 - }; - - std::vector output = - { - 0, 0, 0, 0, 0, 0, 0, 0, - 1, 1, 1, 1, 0, 0, 0, 0 - }; - - return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape, - input0, - shape, - input1, - shape, - output); -} - -LayerTestResult GreaterBroadcast1ElementUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 1 }; - - std::vector input0 = - { - 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12 - }; - - std::vector input1 = { 1 }; - - std::vector output = - { - 0, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1 - }; - - return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape0, - input0, - shape1, - input1, - shape0, - output); -} - -LayerTestResult GreaterBroadcast1DVectorUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int shape0[] = { 1, 2, 2, 3 }; - const unsigned int shape1[] = { 1, 1, 1, 3 }; - - std::vector input0 = - { - 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12 - }; - - std::vector input1 = { 1, 1, 3 }; - - std::vector output = - { - 0, 1, 0, 1, 1, 1, - 1, 1, 1, 1, 1, 1 - }; - - return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>( - workloadFactory, - memoryManager, - armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater), - shape0, - input0, - shape1, - input1, - shape0, - output); -} diff --git a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.hpp deleted file mode 100644 index 060fc28b9a..0000000000 --- a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "LayerTestResult.hpp" - -#include -#include - -LayerTestResult GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterBroadcast1ElementTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterBroadcast1DVectorTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterBroadcast1ElementFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterBroadcast1DVectorFloat16Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterBroadcast1ElementUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult GreaterBroadcast1DVectorUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp index 8879928d27..4e987db0fb 100644 --- a/src/backends/cl/test/ClLayerTests.cpp +++ b/src/backends/cl/test/ClLayerTests.cpp @@ -499,12 +499,13 @@ ARMNN_AUTO_TEST_CASE(MinimumBroadcast1Element2, MinimumBroadcast1ElementTest2) ARMNN_AUTO_TEST_CASE(MinimumBroadcast1DVectorUint8, MinimumBroadcast1DVectorUint8Test) // Greater -ARMNN_AUTO_TEST_CASE(SimpleGreater, GreaterSimpleTest) +ARMNN_AUTO_TEST_CASE(GreaterSimple, GreaterSimpleTest) ARMNN_AUTO_TEST_CASE(GreaterBroadcast1Element, GreaterBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVector, GreaterBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE(GreaterUint8, GreaterUint8Test) +ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVector, GreaterBroadcast1dVectorTest) + +ARMNN_AUTO_TEST_CASE(GreaterSimpleUint8, GreaterSimpleUint8Test) ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVectorUint8, GreaterBroadcast1DVectorUint8Test) +ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorUint8, GreaterBroadcast1dVectorUint8Test) // Softmax ARMNN_AUTO_TEST_CASE(SimpleSoftmaxBeta1, SimpleSoftmaxTest, 1.0f) diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp index 920fb0baf2..50a2d1d630 100644 --- a/src/backends/neon/test/NeonLayerTests.cpp +++ b/src/backends/neon/test/NeonLayerTests.cpp @@ -546,12 +546,13 @@ ARMNN_AUTO_TEST_CASE(L2NormalizationNonDefaultEpsilon, L2NormalizationNonDefault ARMNN_AUTO_TEST_CASE(SimpleFloor, SimpleFloorTest) // Greater -ARMNN_AUTO_TEST_CASE(SimpleGreater, GreaterSimpleTest) +ARMNN_AUTO_TEST_CASE(GreaterSimple, GreaterSimpleTest) ARMNN_AUTO_TEST_CASE(GreaterBroadcast1Element, GreaterBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVector, GreaterBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE(GreaterUint8, GreaterUint8Test) +ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVector, GreaterBroadcast1dVectorTest) + +ARMNN_AUTO_TEST_CASE(GreaterSimpleUint8, GreaterSimpleUint8Test) ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVectorUint8, GreaterBroadcast1DVectorUint8Test) +ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorUint8, GreaterBroadcast1dVectorUint8Test) // Reshape ARMNN_AUTO_TEST_CASE(SimpleReshapeFloat32, SimpleReshapeTest) diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp index 5de9b752ca..1b284c3876 100644 --- a/src/backends/reference/test/RefLayerTests.cpp +++ b/src/backends/reference/test/RefLayerTests.cpp @@ -543,26 +543,82 @@ ARMNN_AUTO_TEST_CASE(DivisionInt16Broadcast1Element, DivisionBroadcast1ElementIn ARMNN_AUTO_TEST_CASE(DivisionInt16Broadcast1DVector, DivisionBroadcast1DVectorInt16Test) // Equal -ARMNN_AUTO_TEST_CASE(SimpleEqual, EqualSimpleTest) +ARMNN_AUTO_TEST_CASE(EqualSimple, EqualSimpleTest) ARMNN_AUTO_TEST_CASE(EqualBroadcast1Element, EqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1DVector, EqualBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE(EqualFloat16, EqualFloat16Test) +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(EqualUint8, EqualUint8Test) +ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVectorFloat16, EqualBroadcast1dVectorFloat16Test) + +ARMNN_AUTO_TEST_CASE(EqualSimpleUint8, EqualSimpleUint8Test) ARMNN_AUTO_TEST_CASE(EqualBroadcast1ElementUint8, EqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(EqualBroadcast1DVectorUint8, EqualBroadcast1DVectorUint8Test) +ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVectorUint8, EqualBroadcast1dVectorUint8Test) // Greater -ARMNN_AUTO_TEST_CASE(SimpleGreater, GreaterSimpleTest) +ARMNN_AUTO_TEST_CASE(GreaterSimple, GreaterSimpleTest) ARMNN_AUTO_TEST_CASE(GreaterBroadcast1Element, GreaterBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVector, GreaterBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE(GreaterUint8, GreaterUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVectorUint8, GreaterBroadcast1DVectorUint8Test) -ARMNN_AUTO_TEST_CASE(GreaterFloat16, GreaterFloat16Test) +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(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) -- cgit v1.2.1