IVGCVSW-3857 Add Reference FP16 workload support to remaining layers

* Adds Reference FP16 support and unit tests for layers not already supported

!referencetests:202156

Signed-off-by: Matthew Jackson <matthew.jackson@arm.com>
Change-Id: I6fc9b9ce2809e163f72e27e877025c8fb85d9fbe

1 files changed, 82 insertions, 2 deletions

diff --git a/src/backends/reference/test/RefCreateWorkloadTests.cpp b/src/backends/reference/test/RefCreateWorkloadTests.cpp
index 04c9acbe39..580d8550f0 100644
--- a/src/backends/reference/test/RefCreateWorkloadTests.cpp
+++ b/src/backends/reference/test/RefCreateWorkloadTests.cpp
@@ -112,7 +112,7 @@ BOOST_AUTO_TEST_CASE(CreateAdditionInt16Workload)
         armnn::DataType::QuantisedSymm16>();
 }
 
-BOOST_AUTO_TEST_CASE(CreateSubtractionFloatWorkload)
+BOOST_AUTO_TEST_CASE(CreateSubtractionFloat32Workload)
 {
     RefCreateElementwiseWorkloadTest<RefSubtractionWorkload,
         SubtractionQueueDescriptor,
@@ -120,6 +120,14 @@ BOOST_AUTO_TEST_CASE(CreateSubtractionFloatWorkload)
         armnn::DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload)
+{
+    RefCreateElementwiseWorkloadTest<RefSubtractionWorkload,
+        SubtractionQueueDescriptor,
+        SubtractionLayer,
+        armnn::DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateSubtractionUint8Workload)
 {
     RefCreateElementwiseWorkloadTest<RefSubtractionWorkload,
@@ -160,7 +168,7 @@ BOOST_AUTO_TEST_CASE(CreateMultiplicationInt16Workload)
         armnn::DataType::QuantisedSymm16>();
 }
 
-BOOST_AUTO_TEST_CASE(CreateDivisionFloatWorkload)
+BOOST_AUTO_TEST_CASE(CreateDivisionFloat32Workload)
 {
     RefCreateElementwiseWorkloadTest<RefDivisionWorkload,
         DivisionQueueDescriptor,
@@ -168,6 +176,14 @@ BOOST_AUTO_TEST_CASE(CreateDivisionFloatWorkload)
         armnn::DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateDivisionFloat16Workload)
+{
+    RefCreateElementwiseWorkloadTest<RefDivisionWorkload,
+        DivisionQueueDescriptor,
+        DivisionLayer,
+        armnn::DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateDivisionUint8Workload)
 {
     RefCreateElementwiseWorkloadTest<RefDivisionWorkload,
@@ -225,6 +241,18 @@ BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat32WorkloadNhwc)
             (DataLayout::NHWC);
 }
 
+BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16Workload)
+{
+    RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload,armnn::DataType::Float16>
+            (DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16WorkloadNhwc)
+{
+    RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::Float16>
+            (DataLayout::NHWC);
+}
+
 BOOST_AUTO_TEST_CASE(CreateBatchNormalizationUint8Workload)
 {
     RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QuantisedAsymm8>
@@ -486,6 +514,11 @@ BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat32Workload)
     RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16Workload)
+{
+    RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateSoftmaxQuantisedAsymm8Workload)
 {
     RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QuantisedAsymm8>();
@@ -523,6 +556,11 @@ BOOST_AUTO_TEST_CASE(CreateSplitterFloat32Workload)
     RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateSplitterFloat16Workload)
+{
+    RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateSplitterUint8Workload)
 {
     RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::QuantisedAsymm8>();
@@ -566,6 +604,11 @@ BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloat32)
     RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloat16)
+{
+    RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateSplitterConcatUint8)
 {
     RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::QuantisedAsymm8>();
@@ -654,6 +697,11 @@ BOOST_AUTO_TEST_CASE(CreateResizeBilinearFloat32)
     RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
 }
 
+BOOST_AUTO_TEST_CASE(CreateResizeBilinearFloat16)
+{
+    RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
+}
+
 BOOST_AUTO_TEST_CASE(CreateResizeBilinearUint8)
 {
     RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::QuantisedAsymm8>(DataLayout::NCHW);
@@ -689,6 +737,11 @@ BOOST_AUTO_TEST_CASE(CreateRsqrtFloat32)
     RefCreateRsqrtTest<RefRsqrtWorkload, armnn::DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateRsqrtFloat16)
+{
+    RefCreateRsqrtTest<RefRsqrtWorkload, armnn::DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateRsqrtUint8)
 {
     RefCreateRsqrtTest<RefRsqrtWorkload, armnn::DataType::QuantisedAsymm8>();
@@ -717,6 +770,11 @@ BOOST_AUTO_TEST_CASE(CreateBatchToSpaceNdFloat32)
     RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateBatchToSpaceNdFloat16)
+{
+    RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateBatchToSpaceNdUint8)
 {
     RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::QuantisedAsymm8>();
@@ -833,6 +891,11 @@ BOOST_AUTO_TEST_CASE(CreateConcatDim0Float32Workload)
     RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
 }
 
+BOOST_AUTO_TEST_CASE(CreateConcatDim0Float16Workload)
+{
+    RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float16>({ 4, 3, 2, 5 }, 0);
+}
+
 BOOST_AUTO_TEST_CASE(CreateConcatDim0Uint8Workload)
 {
     RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QuantisedAsymm8>({ 4, 3, 2, 5 }, 0);
@@ -931,6 +994,11 @@ BOOST_AUTO_TEST_CASE(CreatePreluFloat32Workload)
     RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::Float32);
 }
 
+BOOST_AUTO_TEST_CASE(CreatePreluFloat16Workload)
+{
+    RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::Float16);
+}
+
 BOOST_AUTO_TEST_CASE(CreatePreluUint8Workload)
 {
     RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::QuantisedAsymm8);
@@ -948,6 +1016,13 @@ BOOST_AUTO_TEST_CASE(CreatePreluFloat32NoBroadcastWorkload)
                       armnn::InvalidArgumentException);
 }
 
+BOOST_AUTO_TEST_CASE(CreatePreluFloat16NoBroadcastWorkload)
+{
+    BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
+                                                 armnn::DataType::Float16),
+                      armnn::InvalidArgumentException);
+}
+
 BOOST_AUTO_TEST_CASE(CreatePreluUint8NoBroadcastWorkload)
 {
     BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
@@ -980,6 +1055,11 @@ BOOST_AUTO_TEST_CASE(CreateSpaceToDepthWorkloadFloat32)
     RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateSpaceToDepthWorkloadFloat16)
+{
+    RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float16>();
+}
+
 BOOST_AUTO_TEST_CASE(CreateSpaceToDepthWorkloadQASymm8)
 {
     RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::QuantisedAsymm8>();