commit d0dfe178e3e6729cebd1a60d614f794e3c2ab72d
author Francis Murtagh <francis.murtagh@arm.com> Tue Jun 25 10:57:10 2019 +0100
committer Francis Murtagh <francis.murtagh@arm.com> Wed Jun 26 11:43:29 2019 +0100
tree 8586d52d7b5522d0f5ec5d39cb39b9ff9142d3d7
parent 96a709d87e0ae7d67dfa842c49a7cb9c3f9b5b86

IVGCVSW-3249 Extend the BatchToSpace workload to support QSymm16

 * Add reference supportedness validation checks.
 * Call unit tests with QSymm16 data type.

Change-Id: Ie6621ca7072dfc69278198c53e09b090275a7fff
Signed-off-by: Francis Murtagh <francis.murtagh@arm.com>

src/backends/reference/RefLayerSupport.cpp

diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index 4e9a678..1f37420 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -359,14 +359,45 @@
                                                 Optional<std::string&> reasonIfUnsupported) const
 {
     ignore_unused(descriptor);
-    return (IsSupportedForDataTypeRef(reasonIfUnsupported,
-                                      input.GetDataType(),
-                                      &TrueFunc<>,
-                                      &TrueFunc<>) &&
-            IsSupportedForDataTypeRef(reasonIfUnsupported,
-                                      output.GetDataType(),
-                                      &TrueFunc<>,
-                                      &TrueFunc<>));
+
+    bool supported = true;
+
+    std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
+    std::string inputTensorStr = "input";
+    std::string outputTensorStr = "output";
+
+    // Define supported types.
+    std::array<DataType,3> supportedTypes =
+    {
+            DataType::Float32,
+            DataType::QuantisedAsymm8,
+            DataType::QuantisedSymm16
+    };
+
+    supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+                                  "Reference BatchToSpaceNd: input type not supported.");
+
+    supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+                                  "Reference BatchToSpaceNd: output type not supported.");
+
+    supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+                                  "Reference BatchToSpaceNd: input and output types mismatched.");
+
+    supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4),
+                                  reasonIfUnsupported,
+                                  CreateIncorrectDimensionsErrorMsg(4,
+                                                                    output.GetNumDimensions(),
+                                                                    batchToSpaceNdLayerStr,
+                                                                    outputTensorStr).data());
+
+    supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4),
+                                  reasonIfUnsupported,
+                                  CreateIncorrectDimensionsErrorMsg(4,
+                                                                    input.GetNumDimensions(),
+                                                                    batchToSpaceNdLayerStr,
+                                                                    inputTensorStr).data());
+
+    return supported;
 }
 
 bool RefLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,