IVGCVSW-3399 Add support of QuantisedSymm16 to Permute and unit tests

Signed-off-by: Narumol Prangnawarat <narumol.prangnawarat@arm.com>
Change-Id: Id6ab073ae3e0ff5f60c2f4bef975798ce71c9f88

10 files changed, 181 insertions, 202 deletions

diff --git a/src/backends/backendsCommon/test/LayerTests.cpp b/src/backends/backendsCommon/test/LayerTests.cpp
index 57fcfbb1ce..e8257fdc7a 100644
--- a/src/backends/backendsCommon/test/LayerTests.cpp
+++ b/src/backends/backendsCommon/test/LayerTests.cpp
@@ -38,7 +38,6 @@
 #include "SoftmaxTestImpl.hpp"
 #include "StridedSliceTestImpl.hpp"
 #include "NormTestImpl.hpp"
-#include "PermuteTestImpl.hpp"
 #include "LstmTestImpl.hpp"
 #include "ConvertFp16ToFp32TestImpl.hpp"
 #include "ConvertFp32ToFp16TestImpl.hpp"
@@ -9090,41 +9089,6 @@ LayerTestResult<float, 2> FullyConnectedLargeTest(
     return FullyConnectedLargeTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, transposeWeights);
 }
 
-LayerTestResult<float, 4> SimplePermuteFloat32Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
-    return SimplePermuteFloat32TestCommon(workloadFactory, memoryManager);
-};
-
-LayerTestResult<uint8_t, 4> SimplePermuteUint8Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
-    return SimplePermuteUint8TestCommon(workloadFactory, memoryManager);
-};
-
-LayerTestResult<float, 4> PermuteFloat32ValueSet1Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
-    return PermuteFloat32ValueSet1TestCommon(workloadFactory, memoryManager);
-};
-
-LayerTestResult<float, 4> PermuteFloat32ValueSet2Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
-    return PermuteFloat32ValueSet2TestCommon(workloadFactory, memoryManager);
-};
-
-LayerTestResult<float, 4> PermuteFloat32ValueSet3Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
-    return PermuteFloat32ValueSet3TestCommon(workloadFactory, memoryManager);
-};
-
 LayerTestResult<float, 4> AdditionAfterMaxPoolTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp
index c3ea619eaa..4eb01accc4 100644
--- a/src/backends/backendsCommon/test/LayerTests.hpp
+++ b/src/backends/backendsCommon/test/LayerTests.hpp
@@ -1406,14 +1406,6 @@ LayerTestResult<float, 2> FullyConnectedLargeTest(
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     bool transposeWeights);
 
-LayerTestResult<float, 4> SimplePermuteFloat32Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> SimplePermuteUint8Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
 LayerTestResult<uint8_t, 2> PadUint82dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
@@ -1446,18 +1438,6 @@ LayerTestResult<float, 4> PadFloat324dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 
-LayerTestResult<float, 4> PermuteFloat32ValueSet1Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<float, 4> PermuteFloat32ValueSet2Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<float, 4> PermuteFloat32ValueSet3Test(
-    armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
 void LstmUtilsZeroVectorTest();
 void LstmUtilsMeanStddevNormalizationNoneZeroInputTest();
 void LstmUtilsMeanStddevNormalizationAllZeroInputTest();
diff --git a/src/backends/backendsCommon/test/PermuteTestImpl.hpp b/src/backends/backendsCommon/test/PermuteTestImpl.hpp
index c8120a41d8..5f56fbde59 100644
--- a/src/backends/backendsCommon/test/PermuteTestImpl.hpp
+++ b/src/backends/backendsCommon/test/PermuteTestImpl.hpp
@@ -55,7 +55,8 @@ LayerTestResult<T, 4> SimplePermuteTestImpl(
     return ret;
 }
 
-LayerTestResult<float, 4> SimplePermuteFloat32TestCommon(
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 4> SimplePermuteTest(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
@@ -68,69 +69,39 @@ LayerTestResult<float, 4> SimplePermuteFloat32TestCommon(
     armnn::PermuteDescriptor descriptor;
     descriptor.m_DimMappings = {0U, 3U, 1U, 2U};
 
-    inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::Float32);
-    outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::Float32);
-
-    std::vector<float> input = std::vector<float>(
-            {
-                    1.0f, 2.0f,
-                    3.0f, 4.0f,
-
-                    5.0f, 6.0f,
-                    7.0f, 8.0f
-            });
-
-    std::vector<float> outputExpected = std::vector<float>(
-            {
-                    1.0f, 5.0f, 2.0f, 6.0f,
-                    3.0f, 7.0f, 4.0f, 8.0f
-            });
-
-    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
-                                        descriptor, inputTensorInfo,
-                                        outputTensorInfo, input, outputExpected);
+    inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
+    outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
+
+    // Set quantization parameters if the requested type is a quantized type.
+    if(armnn::IsQuantizedType<T>())
+    {
+        inputTensorInfo.SetQuantizationScale(0.5f);
+        inputTensorInfo.SetQuantizationOffset(5);
+        outputTensorInfo.SetQuantizationScale(0.5f);
+        outputTensorInfo.SetQuantizationOffset(5);
+    }
+
+    std::vector<T> input = std::vector<T>(
+    {
+        1, 2,
+        3, 4,
+        5, 6,
+        7, 8
+    });
+
+    std::vector<T> outputExpected = std::vector<T>(
+    {
+        1, 5, 2, 6,
+        3, 7, 4, 8
+    });
+
+    return SimplePermuteTestImpl<T>(workloadFactory, memoryManager,
+                                    descriptor, inputTensorInfo,
+                                    outputTensorInfo, input, outputExpected);
 }
 
-LayerTestResult<uint8_t, 4> SimplePermuteUint8TestCommon(
-        armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
-    armnn::TensorInfo inputTensorInfo;
-    armnn::TensorInfo outputTensorInfo;
-
-    unsigned int inputShape[] = { 1, 2, 2, 2 };
-    unsigned int outputShape[] = { 1, 2, 2, 2 };
-
-    armnn::PermuteDescriptor descriptor;
-    descriptor.m_DimMappings = {0U, 3U, 1U, 2U};
-
-    inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::QuantisedAsymm8);
-    inputTensorInfo.SetQuantizationScale(1.0f);
-    outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::QuantisedAsymm8);
-    outputTensorInfo.SetQuantizationScale(1.0f);
-
-    std::vector<uint8_t> input = std::vector<uint8_t>(
-            {
-                    1, 2,
-                    3, 4,
-
-                    5, 6,
-                    7, 8
-            });
-
-    std::vector<uint8_t> outputExpected = std::vector<uint8_t>(
-            {
-                    1, 5, 2, 6,
-                    3, 7, 4, 8
-            });
-
-    return SimplePermuteTestImpl<uint8_t>(workloadFactory, memoryManager,
-                                          descriptor, inputTensorInfo,
-                                          outputTensorInfo, input, outputExpected);
-}
-
-LayerTestResult<float, 4>
-PermuteFloat32ValueSet1TestCommon(
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 4> PermuteValueSet1Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
@@ -143,31 +114,40 @@ PermuteFloat32ValueSet1TestCommon(
     armnn::PermuteDescriptor descriptor;
     descriptor.m_DimMappings = {0U, 2U, 3U, 1U};
 
-    inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::Float32);
-    outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::Float32);
-
-    std::vector<float> input = std::vector<float>(
-            {
-                    1.0f,   2.0f,  3.0f,
-                    11.0f, 12.0f, 13.0f,
-                    21.0f, 22.0f, 23.0f,
-                    31.0f, 32.0f, 33.0f,
-            });
-
-    std::vector<float> outputExpected = std::vector<float>(
-            {
-                    1.0f, 11.0f, 21.0f, 31.0f,
-                    2.0f, 12.0f, 22.0f, 32.0f,
-                    3.0f, 13.0f, 23.0f, 33.0f,
-            });
-
-    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
-                                        descriptor, inputTensorInfo,
-                                        outputTensorInfo, input, outputExpected);
+    inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
+    outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
+
+    // Set quantization parameters if the requested type is a quantized type.
+    if(armnn::IsQuantizedType<T>())
+    {
+        inputTensorInfo.SetQuantizationScale(0.5f);
+        inputTensorInfo.SetQuantizationOffset(5);
+        outputTensorInfo.SetQuantizationScale(0.5f);
+        outputTensorInfo.SetQuantizationOffset(5);
+    }
+
+    std::vector<T> input = std::vector<T>(
+    {
+         1,  2,  3,
+        11, 12, 13,
+        21, 22, 23,
+        31, 32, 33
+    });
+
+    std::vector<T> outputExpected = std::vector<T>(
+    {
+        1, 11, 21, 31,
+        2, 12, 22, 32,
+        3, 13, 23, 33
+    });
+
+    return SimplePermuteTestImpl<T>(workloadFactory, memoryManager,
+                                    descriptor, inputTensorInfo,
+                                    outputTensorInfo, input, outputExpected);
 }
 
-LayerTestResult<float, 4>
-PermuteFloat32ValueSet2TestCommon(
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 4> PermuteValueSet2Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
@@ -180,31 +160,40 @@ PermuteFloat32ValueSet2TestCommon(
     armnn::PermuteDescriptor descriptor;
     descriptor.m_DimMappings = {0U, 3U, 1U, 2U};
 
-    inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::Float32);
-    outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::Float32);
-
-    std::vector<float> input = std::vector<float>(
-            {
-                1.0f, 11.0f, 21.0f, 31.0f,
-                2.0f, 12.0f, 22.0f, 32.0f,
-                3.0f, 13.0f, 23.0f, 33.0f,
-            });
-
-    std::vector<float> outputExpected = std::vector<float>(
-            {
-                1.0f,   2.0f,  3.0f,
-                11.0f, 12.0f, 13.0f,
-                21.0f, 22.0f, 23.0f,
-                31.0f, 32.0f, 33.0f,
-            });
-
-    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
-                                        descriptor, inputTensorInfo,
-                                        outputTensorInfo, input, outputExpected);
+    inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
+    outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
+
+    // Set quantization parameters if the requested type is a quantized type.
+    if(armnn::IsQuantizedType<T>())
+    {
+        inputTensorInfo.SetQuantizationScale(0.5f);
+        inputTensorInfo.SetQuantizationOffset(5);
+        outputTensorInfo.SetQuantizationScale(0.5f);
+        outputTensorInfo.SetQuantizationOffset(5);
+    }
+
+    std::vector<T> input = std::vector<T>(
+    {
+        1, 11, 21, 31,
+        2, 12, 22, 32,
+        3, 13, 23, 33
+    });
+
+    std::vector<T> outputExpected = std::vector<T>(
+    {
+         1,  2,  3,
+        11, 12, 13,
+        21, 22, 23,
+        31, 32, 33,
+    });
+
+    return SimplePermuteTestImpl<T>(workloadFactory, memoryManager,
+                                    descriptor, inputTensorInfo,
+                                    outputTensorInfo, input, outputExpected);
 }
 
-LayerTestResult<float, 4>
-PermuteFloat32ValueSet3TestCommon(
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 4> PermuteValueSet3Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
@@ -217,27 +206,36 @@ PermuteFloat32ValueSet3TestCommon(
     armnn::PermuteDescriptor descriptor;
     descriptor.m_DimMappings = {0U, 2U, 3U, 1U};
 
-    inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::Float32);
-    outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::Float32);
+    inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
+    outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
+
+    // Set quantization parameters if the requested type is a quantized type.
+    if(armnn::IsQuantizedType<T>())
+    {
+        inputTensorInfo.SetQuantizationScale(0.5f);
+        inputTensorInfo.SetQuantizationOffset(5);
+        outputTensorInfo.SetQuantizationScale(0.5f);
+        outputTensorInfo.SetQuantizationOffset(5);
+    }
 
-    std::vector<float> input = std::vector<float>(
+    std::vector<T> input = std::vector<T>(
             {
-                1.0f,   2.0f,  3.0f,
-                11.0f, 12.0f, 13.0f,
-                21.0f, 22.0f, 23.0f,
-                31.0f, 32.0f, 33.0f,
-                41.0f, 42.0f, 43.0f,
-                51.0f, 52.0f, 53.0f,
+                 1,  2,  3,
+                11, 12, 13,
+                21, 22, 23,
+                31, 32, 33,
+                41, 42, 43,
+                51, 52, 53
             });
 
-    std::vector<float> outputExpected = std::vector<float>(
+    std::vector<T> outputExpected = std::vector<T>(
             {
-                1.0f, 11.0f, 21.0f, 31.0f, 41.0f, 51.0f,
-                2.0f, 12.0f, 22.0f, 32.0f, 42.0f, 52.0f,
-                3.0f, 13.0f, 23.0f, 33.0f, 43.0f, 53.0f,
+                1, 11, 21, 31, 41, 51,
+                2, 12, 22, 32, 42, 52,
+                3, 13, 23, 33, 43, 53
             });
 
-    return SimplePermuteTestImpl<float>(workloadFactory, memoryManager,
-                                        descriptor, inputTensorInfo,
-                                        outputTensorInfo, input, outputExpected);
+    return SimplePermuteTestImpl<T>(workloadFactory, memoryManager,
+                                    descriptor, inputTensorInfo,
+                                    outputTensorInfo, input, outputExpected);
 }
diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp
index 20eb413762..ac96bf8135 100644
--- a/src/backends/cl/test/ClLayerTests.cpp
+++ b/src/backends/cl/test/ClLayerTests.cpp
@@ -16,6 +16,7 @@
 #include <reference/RefWorkloadFactory.hpp>
 #include <backendsCommon/test/ActivationFixture.hpp>
 #include <backendsCommon/test/LayerTests.hpp>
+#include <backendsCommon/test/PermuteTestImpl.hpp>
 
 #include <arm_compute/core/CL/CLKernelLibrary.h>
 #include <arm_compute/runtime/CL/CLScheduler.h>
@@ -336,11 +337,14 @@ ARMNN_AUTO_TEST_CASE(PreluFloat32, PreluTest<armnn::DataType::Float32>)
 ARMNN_AUTO_TEST_CASE(PreluUint8,   PreluTest<armnn::DataType::QuantisedAsymm8>)
 
 // Permute
-ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteFloat32Test)
-ARMNN_AUTO_TEST_CASE(SimplePermuteUint8, SimplePermuteUint8Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1, PermuteFloat32ValueSet1Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2, PermuteFloat32ValueSet2Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3, PermuteFloat32ValueSet3Test)
+ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1Test, PermuteValueSet1Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2Test, PermuteValueSet2Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3Test, PermuteValueSet3Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(SimplePermuteQASymm8, SimplePermuteTest<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test<armnn::DataType::QuantisedAsymm8>)
 
 // Lstm
 ARMNN_AUTO_TEST_CASE(LstmLayerFloat32WithCifgWithPeepholeNoProjection,
diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp
index 77413bd8bb..0177901a52 100644
--- a/src/backends/neon/test/NeonLayerTests.cpp
+++ b/src/backends/neon/test/NeonLayerTests.cpp
@@ -14,6 +14,7 @@
 #include <reference/RefWorkloadFactory.hpp>
 #include <backendsCommon/test/ActivationFixture.hpp>
 #include <backendsCommon/test/LayerTests.hpp>
+#include <backendsCommon/test/PermuteTestImpl.hpp>
 #include <backendsCommon/test/TensorCopyUtils.hpp>
 #include <backendsCommon/test/WorkloadTestUtils.hpp>
 
@@ -432,11 +433,14 @@ ARMNN_AUTO_TEST_CASE(PadUint83d, PadUint83dTest)
 ARMNN_AUTO_TEST_CASE(PadUint84d, PadUint84dTest)
 
 // Permute
-ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteFloat32Test)
-ARMNN_AUTO_TEST_CASE(SimplePermuteUint8, SimplePermuteUint8Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1, PermuteFloat32ValueSet1Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2, PermuteFloat32ValueSet2Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3, PermuteFloat32ValueSet3Test)
+ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1Test, PermuteValueSet1Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2Test, PermuteValueSet2Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3Test, PermuteValueSet3Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(SimplePermuteQASymm8, SimplePermuteTest<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test<armnn::DataType::QuantisedAsymm8>)
 
 // Lstm
 ARMNN_AUTO_TEST_CASE(LstmLayerFloat32WithCifgWithPeepholeNoProjection,
diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index f3758760fc..087acd2103 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -1253,12 +1253,27 @@ bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
                                          const PermuteDescriptor& descriptor,
                                          Optional<std::string&> reasonIfUnsupported) const
 {
-    ignore_unused(output);
     ignore_unused(descriptor);
-    return IsSupportedForDataTypeRef(reasonIfUnsupported,
-                                     input.GetDataType(),
-                                     &TrueFunc<>,
-                                     &TrueFunc<>);
+    bool supported = true;
+
+    // Define supported output and inputs types.
+    std::array<DataType,3> supportedTypes =
+    {
+        DataType::Float32,
+        DataType::QuantisedAsymm8,
+        DataType::QuantisedSymm16
+    };
+
+    supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+                                  "Reference permute: input is not a supported type.");
+
+    supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+                                  "Reference permute: output is not a supported type.");
+
+    supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+                                  "Reference permute: input and output types are mismatched.");
+
+    return supported;
 }
 
 bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp
index d1189a6542..9a31533cba 100644
--- a/src/backends/reference/RefWorkloadFactory.cpp
+++ b/src/backends/reference/RefWorkloadFactory.cpp
@@ -172,7 +172,11 @@ std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateFullyConnected(
 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreatePermute(const PermuteQueueDescriptor& descriptor,
                                                                     const WorkloadInfo&           info) const
 {
-    return MakeWorkloadHelper<RefPermuteFloat16Workload, RefPermuteFloat32Workload, RefPermuteUint8Workload,
+    if (IsQSymm16(info))
+    {
+        return std::make_unique<RefPermuteQSymm16Workload>(descriptor, info);
+    }
+    return MakeWorkloadHelper<RefPermuteFloat16Workload, RefPermuteFloat32Workload, RefPermuteQAsymm8Workload,
         NullWorkload, NullWorkload>(descriptor, info);
 }
 
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index 5542c9ae4f..7009dec098 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -13,6 +13,7 @@
 #include <backendsCommon/test/DebugTestImpl.hpp>
 #include <backendsCommon/test/DetectionPostProcessLayerTestImpl.hpp>
 #include <backendsCommon/test/LayerTests.hpp>
+#include <backendsCommon/test/PermuteTestImpl.hpp>
 
 #include <boost/test/unit_test.hpp>
 
@@ -821,11 +822,18 @@ ARMNN_AUTO_TEST_CASE(Rsqrt2dQuantisedSymm16, Rsqrt2dTest<armnn::DataType::Quanti
 ARMNN_AUTO_TEST_CASE(Rsqrt3dQuantisedSymm16, Rsqrt3dTest<armnn::DataType::QuantisedSymm16>)
 
 // Permute
-ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteFloat32Test)
-ARMNN_AUTO_TEST_CASE(SimplePermuteUint8, SimplePermuteUint8Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1, PermuteFloat32ValueSet1Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2, PermuteFloat32ValueSet2Test)
-ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3, PermuteFloat32ValueSet3Test)
+ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1Test, PermuteValueSet1Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2Test, PermuteValueSet2Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3Test, PermuteValueSet3Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(SimplePermuteQASymm8, SimplePermuteTest<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(SimplePermuteQSymm16, SimplePermuteTest<armnn::DataType::QuantisedSymm16>)
+ARMNN_AUTO_TEST_CASE(PermuteQSymm16ValueSet1Test, PermuteValueSet1Test<armnn::DataType::QuantisedSymm16>)
+ARMNN_AUTO_TEST_CASE(PermuteQSymm16ValueSet2Test, PermuteValueSet2Test<armnn::DataType::QuantisedSymm16>)
+ARMNN_AUTO_TEST_CASE(PermuteQSymm16ValueSet3Test, PermuteValueSet3Test<armnn::DataType::QuantisedSymm16>)
 
 // Lstm
 BOOST_AUTO_TEST_CASE(LstmUtilsZeroVector) {
diff --git a/src/backends/reference/workloads/RefPermuteWorkload.cpp b/src/backends/reference/workloads/RefPermuteWorkload.cpp
index c943eb84b8..4d43b7e560 100644
--- a/src/backends/reference/workloads/RefPermuteWorkload.cpp
+++ b/src/backends/reference/workloads/RefPermuteWorkload.cpp
@@ -30,5 +30,6 @@ void RefPermuteWorkload<DataType>::Execute() const
 template class RefPermuteWorkload<DataType::Float16>;
 template class RefPermuteWorkload<DataType::Float32>;
 template class RefPermuteWorkload<DataType::QuantisedAsymm8>;
+template class RefPermuteWorkload<DataType::QuantisedSymm16>;
 
 } //namespace armnn
diff --git a/src/backends/reference/workloads/RefPermuteWorkload.hpp b/src/backends/reference/workloads/RefPermuteWorkload.hpp
index a2d32331b2..1e69afb0ed 100644
--- a/src/backends/reference/workloads/RefPermuteWorkload.hpp
+++ b/src/backends/reference/workloads/RefPermuteWorkload.hpp
@@ -29,6 +29,7 @@ public:
 
 using RefPermuteFloat16Workload = RefPermuteWorkload<DataType::Float16>;
 using RefPermuteFloat32Workload = RefPermuteWorkload<DataType::Float32>;
-using RefPermuteUint8Workload   = RefPermuteWorkload<DataType::QuantisedAsymm8>;
+using RefPermuteQAsymm8Workload = RefPermuteWorkload<DataType::QuantisedAsymm8>;
+using RefPermuteQSymm16Workload = RefPermuteWorkload<DataType::QuantisedSymm16>;
 
 } //namespace armnn
\ No newline at end of file