From 2b4d88e34ac1f965417fd236fd4786f26bae2042 Mon Sep 17 00:00:00 2001
From: kevmay01 <kevin.may@arm.com>
Date: Thu, 24 Jan 2019 14:05:09 +0000
Subject: IVGCVSW-2503 Refactor RefElementwiseWorkload around Equal and Greater

	* Remove Equal and Greater from RefElementwiseWorkload
	* Create RefComparisonWorkload and add Equal and Greater
	* Update ElementwiseFunction for different input/output types
	* Update TfParser to create Equal/Greater with Boolean output
	* Update relevant tests to check for Boolean comparison

Change-Id: I299b7f2121769c960ac0c6139764a5f3c89c9c32
---
 src/backends/reference/test/RefEndToEndTests.cpp | 48 ++++++++++++++++--------
 1 file changed, 32 insertions(+), 16 deletions(-)

(limited to 'src/backends/reference/test')

diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp
index 330f406265..802167a3a0 100644
--- a/src/backends/reference/test/RefEndToEndTests.cpp
+++ b/src/backends/reference/test/RefEndToEndTests.cpp
@@ -315,18 +315,22 @@ BOOST_AUTO_TEST_CASE(TrivialMin)
 
 BOOST_AUTO_TEST_CASE(RefEqualSimpleEndToEndTest)
 {
-    const std::vector<float > expectedOutput({ 1, 1, 1, 1,  0, 0, 0, 0,
-                                               0, 0, 0, 0,  1, 1, 1, 1 });
+    const std::vector<uint8_t> expectedOutput({ 1, 1, 1, 1,  0, 0, 0, 0,
+                                                0, 0, 0, 0,  1, 1, 1, 1 });
 
-    ArithmeticSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, LayerType::Equal, expectedOutput);
+    ArithmeticSimpleEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
+                                                                                 LayerType::Equal,
+                                                                                 expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefGreaterSimpleEndToEndTest)
 {
-    const std::vector<float> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
-                                              0, 0, 0, 0,  0, 0, 0, 0 });
+    const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
+                                                0, 0, 0, 0,  0, 0, 0, 0 });
 
-    ArithmeticSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, LayerType::Greater, expectedOutput);
+    ArithmeticSimpleEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
+                                                                                 LayerType::Greater,
+                                                                                 expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefEqualSimpleEndToEndUint8Test)
@@ -334,7 +338,9 @@ BOOST_AUTO_TEST_CASE(RefEqualSimpleEndToEndUint8Test)
     const std::vector<uint8_t> expectedOutput({ 1, 1, 1, 1,  0, 0, 0, 0,
                                                 0, 0, 0, 0,  1, 1, 1, 1 });
 
-    ArithmeticSimpleEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, LayerType::Equal, expectedOutput);
+    ArithmeticSimpleEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
+                                                                                         LayerType::Equal,
+                                                                                         expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefGreaterSimpleEndToEndUint8Test)
@@ -342,23 +348,29 @@ BOOST_AUTO_TEST_CASE(RefGreaterSimpleEndToEndUint8Test)
     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 
-    ArithmeticSimpleEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, LayerType::Greater, expectedOutput);
+    ArithmeticSimpleEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
+                                                                                         LayerType::Greater,
+                                                                                         expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefEqualBroadcastEndToEndTest)
 {
-    const std::vector<float > expectedOutput({ 1, 0, 1, 1, 0, 0,
-                                               0, 0, 0, 0, 0, 0 });
+    const std::vector<uint8_t> expectedOutput({ 1, 0, 1, 1, 0, 0,
+                                                0, 0, 0, 0, 0, 0 });
 
-    ArithmeticBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends, LayerType::Equal, expectedOutput);
+    ArithmeticBroadcastEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
+                                                                                    LayerType::Equal,
+                                                                                    expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefGreaterBroadcastEndToEndTest)
 {
-    const std::vector<float> expectedOutput({ 0, 1, 0, 0, 0, 1,
-                                              1, 1, 1, 1, 1, 1 });
+    const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
+                                                1, 1, 1, 1, 1, 1 });
 
-    ArithmeticBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends, LayerType::Greater, expectedOutput);
+    ArithmeticBroadcastEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
+                                                                                    LayerType::Greater,
+                                                                                    expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefEqualBroadcastEndToEndUint8Test)
@@ -366,7 +378,9 @@ BOOST_AUTO_TEST_CASE(RefEqualBroadcastEndToEndUint8Test)
     const std::vector<uint8_t > expectedOutput({ 1, 0, 1, 1, 0, 0,
                                                  0, 0, 0, 0, 0, 0 });
 
-    ArithmeticBroadcastEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, LayerType::Equal, expectedOutput);
+    ArithmeticBroadcastEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
+                                                                                            LayerType::Equal,
+                                                                                            expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefGreaterBroadcastEndToEndUint8Test)
@@ -374,7 +388,9 @@ BOOST_AUTO_TEST_CASE(RefGreaterBroadcastEndToEndUint8Test)
     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
                                                 1, 1, 1, 1, 1, 1 });
 
-    ArithmeticBroadcastEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, LayerType::Greater, expectedOutput);
+    ArithmeticBroadcastEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
+                                                                                            LayerType::Greater,
+                                                                                            expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(RefMergerEndToEndDim0Test)
-- 
cgit v1.2.1