IVGCVSW-3824 Implement Float 16 Encoder and Decoder

* Implement Float 16 Encoder and Decoder
* Add Stack Float 16 layer and create workload tests

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

6 files changed, 73 insertions, 25 deletions

diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index 5c53f12eb1..5692f9e143 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -1481,9 +1481,10 @@ bool RefLayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inp
     ignore_unused(descriptor);
 
     bool supported = true;
-    std::array<DataType,3> supportedTypes =
+    std::array<DataType,4> supportedTypes =
     {
         DataType::Float32,
+        DataType::Float16,
         DataType::QuantisedAsymm8,
         DataType::QuantisedSymm16
     };
diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp
index dc97356d57..f2dfb980b3 100644
--- a/src/backends/reference/RefWorkloadFactory.cpp
+++ b/src/backends/reference/RefWorkloadFactory.cpp
@@ -528,10 +528,6 @@ std::unique_ptr<IWorkload> RefWorkloadFactory::CreateTransposeConvolution2d(
 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateStack(const StackQueueDescriptor& descriptor,
                                                            const WorkloadInfo& info) const
 {
-    if (IsFloat16(info))
-    {
-        return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
-    }
     return std::make_unique<RefStackWorkload>(descriptor, info);
 }
 
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index af9f645a54..da036a6758 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -1335,11 +1335,12 @@ ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dInt16Nhwc,
                      DataLayout::NCHW)
 
 // Stack
-ARMNN_AUTO_TEST_CASE(Stack0Axis,               Stack0AxisTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(Stack4dOutput1Axis,       Stack4dOutput1AxisTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(Stack4dOutput2Axis,       Stack4dOutput2AxisTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(Stack4dOutput3Axis,       Stack4dOutput3AxisTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(Stack3dOutput1Axis3Input, Stack3dOutput1Axis3InputTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(Stack5dOutput,            Stack5dOutputTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(Stack0Axis,           StackAxis0Float32Test)
+ARMNN_AUTO_TEST_CASE(StackOutput4DAxis1,   StackOutput4DAxis1Float32Test)
+ARMNN_AUTO_TEST_CASE(StackOutput4DAxis2,   StackOutput4DAxis2Float32Test)
+ARMNN_AUTO_TEST_CASE(StackOutput4DAxis3,   StackOutput4DAxis3Float32Test)
+ARMNN_AUTO_TEST_CASE(StackOutput3DInputs3, StackOutput3DInputs3Float32Test)
+ARMNN_AUTO_TEST_CASE(StackOutput5D,        StackOutput5DFloat32Test)
+ARMNN_AUTO_TEST_CASE(StackFloat16,         StackFloat16Test)
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/backends/reference/workloads/BaseIterator.hpp b/src/backends/reference/workloads/BaseIterator.hpp
index c9fd773d5e..18270faf46 100644
--- a/src/backends/reference/workloads/BaseIterator.hpp
+++ b/src/backends/reference/workloads/BaseIterator.hpp
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "FloatingPointConverter.hpp"
+
 #include <armnn/ArmNN.hpp>
 #include <ResolveType.hpp>
 
@@ -142,14 +144,31 @@ private:
     const int32_t m_Offset;
 };
 
-class FloatDecoder : public TypedIterator<const float, Decoder<float>>
+class Float16Decoder : public TypedIterator<const Half, Decoder<float>>
 {
 public:
-    FloatDecoder(const float* data)
+    Float16Decoder(const Half* data)
         : TypedIterator(data) {}
 
-    FloatDecoder()
-        : FloatDecoder(nullptr) {}
+    Float16Decoder()
+        : Float16Decoder(nullptr) {}
+
+    float Get() const override
+    {
+        float val = 0.f;
+        armnnUtils::FloatingPointConverter::ConvertFloat16To32(m_Iterator, 1, &val);
+        return val;
+    }
+};
+
+class Float32Decoder : public TypedIterator<const float, Decoder<float>>
+{
+public:
+    Float32Decoder(const float* data)
+        : TypedIterator(data) {}
+
+    Float32Decoder()
+        : Float32Decoder(nullptr) {}
 
     float Get() const override
     {
@@ -238,14 +257,36 @@ private:
     const int32_t m_Offset;
 };
 
-class FloatEncoder : public TypedIterator<float, Encoder<float>>
+class Float16Encoder : public TypedIterator<Half, Encoder<float>>
+{
+public:
+    Float16Encoder(Half* data)
+        : TypedIterator(data) {}
+
+    Float16Encoder()
+        : Float16Encoder(nullptr) {}
+
+    void Set(float right) override
+    {
+        armnnUtils::FloatingPointConverter::ConvertFloat32To16(&right, 1, m_Iterator);
+    }
+
+    float Get() const override
+    {
+        float val = 0.f;
+        armnnUtils::FloatingPointConverter::ConvertFloat16To32(m_Iterator, 1, &val);
+        return val;
+    }
+};
+
+class Float32Encoder : public TypedIterator<float, Encoder<float>>
 {
 public:
-    FloatEncoder(float* data)
+    Float32Encoder(float* data)
         : TypedIterator(data) {}
 
-    FloatEncoder()
-        : FloatEncoder(nullptr) {}
+    Float32Encoder()
+        : Float32Encoder(nullptr) {}
 
     void Set(float right) override
     {
diff --git a/src/backends/reference/workloads/Decoders.hpp b/src/backends/reference/workloads/Decoders.hpp
index 0101789bec..328a5eb0f7 100644
--- a/src/backends/reference/workloads/Decoders.hpp
+++ b/src/backends/reference/workloads/Decoders.hpp
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "BaseIterator.hpp"
+#include "FloatingPointConverter.hpp"
 
 #include <boost/assert.hpp>
 
@@ -20,25 +21,29 @@ inline std::unique_ptr<Decoder<float>> MakeDecoder(const TensorInfo& info, const
 {
     switch(info.GetDataType())
     {
-        case armnn::DataType::QuantisedAsymm8:
+        case DataType::QuantisedAsymm8:
         {
             return std::make_unique<QASymm8Decoder>(
                 static_cast<const uint8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
-        case armnn::DataType::QuantisedSymm16:
+        case DataType::QuantisedSymm16:
         {
             return std::make_unique<QSymm16Decoder>(
                 static_cast<const int16_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
-        case armnn::DataType::Float32:
+        case DataType::Float16:
         {
-            return std::make_unique<FloatDecoder>(static_cast<const float*>(data));
+            return std::make_unique<Float16Decoder>(static_cast<const Half*>(data));
         }
-        case armnn::DataType::Signed32:
+        case DataType::Float32:
+        {
+            return std::make_unique<Float32Decoder>(static_cast<const float*>(data));
+        }
+        case DataType::Signed32:
         {
             const float scale = info.GetQuantizationScale();
             if (scale == 0.f)
diff --git a/src/backends/reference/workloads/Encoders.hpp b/src/backends/reference/workloads/Encoders.hpp
index f0e40d224b..2b3a11af06 100644
--- a/src/backends/reference/workloads/Encoders.hpp
+++ b/src/backends/reference/workloads/Encoders.hpp
@@ -38,9 +38,13 @@ inline std::unique_ptr<Encoder<float>> MakeEncoder(const TensorInfo& info, void*
         {
             return std::make_unique<Int32Encoder>(static_cast<int32_t*>(data));
         }
+        case armnn::DataType::Float16:
+        {
+            return std::make_unique<Float16Encoder>(static_cast<Half*>(data));
+        }
         case armnn::DataType::Float32:
         {
-            return std::make_unique<FloatEncoder>(static_cast<float*>(data));
+            return std::make_unique<Float32Encoder>(static_cast<float*>(data));
         }
         default:
         {