IVGCVSW-7345 Add Pooling2d support to TOSA Reference Backend

Signed-off-by: Cathal Corbett <cathal.corbett@arm.com>
Change-Id: I73a47e513fe2d064ef233b121a68ef2edf0396dc

2 files changed, 165 insertions, 10 deletions

diff --git a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
index 54d6db6cef..fbe1265fe3 100644
--- a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
@@ -6,27 +6,60 @@
 #include "backendsCommon/test/EndToEndTestImpl.hpp"
 
 #include "backendsCommon/test/AdditionEndToEndTestImpl.hpp"
+#include "backendsCommon/test/Pooling2dEndToEndTestImpl.hpp"
 
 #include <doctest/doctest.h>
 
 TEST_SUITE("TosaRefEndToEnd")
 {
-std::vector<armnn::BackendId> tosaDefaultBackends = { "TosaRef" };
+std::vector<BackendId> tosaDefaultBackends = { "TosaRef" };
 
 // Addition
-TEST_CASE("TosaRefEndtoEndTestFloat32")
+TEST_CASE("TosaRefAdditionEndtoEndTestFloat32")
 {
-    AdditionEndToEnd<armnn::DataType::Float32>(tosaDefaultBackends);
+    AdditionEndToEnd<DataType::Float32>(tosaDefaultBackends);
 }
 
-TEST_CASE("TosaRefEndtoEndTestInt32")
+TEST_CASE("TosaRefAdditionEndtoEndTestInt32")
 {
-    AdditionEndToEnd<armnn::DataType::Signed32>(tosaDefaultBackends);
+    AdditionEndToEnd<DataType::Signed32>(tosaDefaultBackends);
 }
 
-TEST_CASE("TosaRefEndtoEndTestFloat16")
+TEST_CASE("TosaRefAdditionEndtoEndTestFloat16")
 {
-    AdditionEndToEndFloat16<armnn::DataType::Float16>(tosaDefaultBackends);
+    AdditionEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
+}
+
+// Max Pool 2D
+TEST_CASE("TosaRefMaxPool2DEndtoEndTestFloat32")
+{
+    MaxPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends);
+}
+
+TEST_CASE("TosaRefMaxPool2DEndtoEndTestFloat16")
+{
+    MaxPool2dEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
+}
+
+TEST_CASE("TosaRefMaxPool2DIgnoreValueEndtoEndTestFloat32")
+{
+    MaxPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends, PaddingMethod::IgnoreValue);
+}
+
+// Average Pool 2D
+TEST_CASE("TosaRefAvgPool2DEndtoEndTestFloat32")
+{
+    AvgPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends);
+}
+
+TEST_CASE("TosaRefAvgPool2DEndtoEndTestFloat16")
+{
+    AvgPool2dEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
+}
+
+TEST_CASE("TosaRefAvgPool2DIgnoreValueEndtoEndTestFloat32")
+{
+    AvgPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends, PaddingMethod::IgnoreValue);
 }
 
 }
\ No newline at end of file
diff --git a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
index 47f31380a5..48eca344bc 100644
--- a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
@@ -57,9 +57,131 @@ TEST_CASE("IsLayerSupportedTosaReferenceAdditionUnsupported")
                                                      reasonIfNotSupported);
 
     CHECK(!supported);
-    REQUIRE(reasonIfNotSupported.find("TOSA Reference Operator: 14 for input: Op_ADD_input0_") != std::string::npos);
-    REQUIRE(reasonIfNotSupported.find("TOSA Reference Operator: 14 for input: Op_ADD_input1_") != std::string::npos);
-    REQUIRE(reasonIfNotSupported.find("TOSA Reference Operator: 14 for output: Op_ADD_output0_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+        "TOSA Reference Operator: Op_ADD for input: Op_ADD_input0_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+        "TOSA Reference Operator: Op_ADD for input: Op_ADD_input1_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+        "TOSA Reference Operator: Op_ADD for output: Op_ADD_output0_") != std::string::npos);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceMaxPooling2d")
+{
+    armnn::TensorShape inShape = {1,1,3,4};
+    armnn::TensorShape outShape = {1,1,3,4};
+    armnn::TensorInfo in(inShape, armnn::DataType::Float32);
+    armnn::TensorInfo out(outShape, armnn::DataType::Float32);
+
+    armnn::Pooling2dDescriptor desc;
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Pooling2d,
+                                                     {in, out},
+                                                     desc,
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(supported);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2d_IgnoreValue")
+{
+    armnn::TensorShape inShape = {1,1,3,4};
+    armnn::TensorShape outShape = {1,1,3,4};
+    armnn::TensorInfo in(inShape, armnn::DataType::Float32);
+    armnn::TensorInfo out(outShape, armnn::DataType::Float32);
+
+    armnn::Pooling2dDescriptor desc;
+    desc.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
+    desc.m_PoolType = armnn::PoolingAlgorithm::Average;
+
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Pooling2d,
+                                                     {in, out},
+                                                     desc,
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(supported);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2d_InputOutputDatatypeDifferent")
+{
+    armnn::TensorShape inShape = {1,1,3,4};
+    armnn::TensorShape outShape = {1,1,3,4};
+    armnn::TensorInfo in(inShape, armnn::DataType::QAsymmS8);
+    armnn::TensorInfo out(outShape, armnn::DataType::Signed32);
+
+    armnn::Pooling2dDescriptor desc;
+    desc.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
+    desc.m_PoolType = armnn::PoolingAlgorithm::Average;
+
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Pooling2d,
+                                                     {in, out},
+                                                     desc,
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(supported);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceMaxPooling2dUnsupported")
+{
+    armnn::TensorShape inShape = {1,1,3,4};
+    armnn::TensorShape outShape = {1,1,3,4};
+    armnn::TensorInfo in(inShape, armnn::DataType::Signed64);
+    armnn::TensorInfo out(outShape, armnn::DataType::Signed64);
+
+    armnn::Pooling2dDescriptor desc;
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Pooling2d,
+                                                     {in, out},
+                                                     desc,
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(!supported);
+    REQUIRE(reasonIfNotSupported.find(
+        "TOSA Reference Operator: Op_MAX_POOL2D for input: Op_MAX_POOL2D_input0_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+        "TOSA Reference Operator: Op_MAX_POOL2D for output: Op_MAX_POOL2D_output0_") != std::string::npos);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2dUnsupported_InputOutputDatatypeDifferent")
+{
+    armnn::TensorShape inShape = {1,1,3,4};
+    armnn::TensorShape outShape = {1,1,3,4};
+    armnn::TensorInfo in(inShape, armnn::DataType::Float32);
+    armnn::TensorInfo out(outShape, armnn::DataType::Float16);
+
+    armnn::Pooling2dDescriptor desc;
+    desc.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
+    desc.m_PoolType = armnn::PoolingAlgorithm::Average;
+
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Pooling2d,
+                                                     {in, out},
+                                                     desc,
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(!supported);
+    REQUIRE(reasonIfNotSupported.find(
+        "TOSA Reference Operator: Op_AVG_POOL2D for input: Op_PAD_intermediate0_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+        " and output: Op_AVG_POOL2D_output0_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+        " has an unsupported input data type: 8 to output data type: 10") != std::string::npos);
 }
 
 }