Small fixes in TOSA common and TOSA reference:

* alphabetical order,
* specify floats
* fix order of parameters in convolution operator
* fix uninitiated variable in ConvertConstantTensorDataToBuffer

Signed-off-by: Teresa Charlin <teresa.charlinreyes@arm.com>
Change-Id: Ic82e6127cac6b94da4c859a284893b838ab248bc

5 files changed, 60 insertions, 60 deletions

diff --git a/src/backends/backendsCommon/test/Pooling2dEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/Pooling2dEndToEndTestImpl.hpp
index addd27caca..026dbfd9b6 100644
--- a/src/backends/backendsCommon/test/Pooling2dEndToEndTestImpl.hpp
+++ b/src/backends/backendsCommon/test/Pooling2dEndToEndTestImpl.hpp
@@ -117,15 +117,15 @@ void AvgPool2dEndToEnd(const std::vector<armnn::BackendId>& backends,
     std::vector<T> expectedOutput;
     if (padMethod == PaddingMethod::Exclude)
     {
-        expectedOutput  = { 3  , 3.5 , 4 ,
-                            4.5, 5  , 5.5,
-                            6  , 6.5, 7  };
+        expectedOutput  = { 3.f , 3.5f, 4.f ,
+                            4.5f, 5.f , 5.5f,
+                            6.f , 6.5f, 7.f  };
     }
     else
     {
-        expectedOutput  = { 1.33333, 2.33333, 1.77778,
-                            3      , 5      , 3.66667,
-                            2.66667, 4.33333, 3.11111 };
+        expectedOutput  = { 1.33333f, 2.33333f, 1.77778f,
+                            3.f     , 5.f     , 3.66667f,
+                            2.66667f, 4.33333f, 3.11111f };
     }
 
     std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
diff --git a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
index dadd91b227..6fc1678c81 100644
--- a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
@@ -114,7 +114,7 @@ TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer,
                                static_cast<int>(conv2dDescriptor->m_StrideX)};
     std::vector<int> dilation = {static_cast<int>(conv2dDescriptor->m_DilationY),
                                  static_cast<int>(conv2dDescriptor->m_DilationX)};
-    TosaConvAttribute attribute(pad, dilation, stride, 0, 0, ArmNNToDType(inputs[0]->GetDataType()));
+    TosaConvAttribute attribute(pad, stride, dilation, 0, 0, ArmNNToDType(inputs[0]->GetDataType()));
 
     auto* op = new TosaSerializationOperator(Op_CONV2D,
                                              Attribute_ConvAttribute,
diff --git a/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
index be2f53e413..dccb29892c 100644
--- a/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
+++ b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
@@ -279,7 +279,7 @@ inline std::string TosaOpToString(Op tosaOp)
 
 inline std::vector<uint8_t> ConvertConstantTensorDataToBuffer(const std::shared_ptr<ConstTensorHandle>& tensorHandle)
 {
-    tosa_err_t error;
+    tosa_err_t error = tosa_err_t::TOSA_OK;
     std::vector<uint8_t> uint8Data;
     auto tensorInfo = tensorHandle->GetTensorInfo();
 
diff --git a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
index 2b0c1e55c7..e74c638ee9 100644
--- a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
+++ b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
@@ -177,10 +177,10 @@ TEST_CASE("GetTosaMappingFromLayer_Conv2dLayer")
         basicBlock, inputShape, outputShape, Op_CONV2D, Attribute_ConvAttribute, descriptor, LayerType::Convolution2d);
 }
 
-TEST_CASE("GetTosaMapping_MaxPool2DLayer")
+TEST_CASE("GetTosaMapping_AvgPool2DLayer")
 {
     Pooling2dDescriptor descriptor;
-    descriptor.m_PoolType = PoolingAlgorithm::Max;
+    descriptor.m_PoolType = PoolingAlgorithm::Average;
     descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
     descriptor.m_StrideX = descriptor.m_StrideY = 2;
     descriptor.m_PadLeft = 1;
@@ -196,12 +196,17 @@ TEST_CASE("GetTosaMapping_MaxPool2DLayer")
     std::vector<std::vector<int32_t>> outputShape = {{ 1, 1, 3, 3 }};
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMapping(nullptr, LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor);
-    AssertTosaOneToOneMappingBasicBlock(
-        basicBlock, inputShape, outputShape, Op_MAX_POOL2D, Attribute_PoolAttribute, descriptor, LayerType::Pooling2d);
+            GetTosaMapping(nullptr, LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor);
+    AssertTosaOneToOneMappingBasicBlock(basicBlock,
+                                        inputShape,
+                                        outputShape,
+                                        Op_AVG_POOL2D,
+                                        Attribute_PoolAttribute,
+                                        descriptor,
+                                        LayerType::Pooling2d);
 }
 
-TEST_CASE("GetTosaMappingFromLayer_MaxPool2DLayer")
+TEST_CASE("GetTosaMappingFromLayer_AvgPool2DLayer")
 {
     IRuntime::CreationOptions options;
     IRuntimePtr runtime(IRuntime::Create(options));
@@ -210,7 +215,7 @@ TEST_CASE("GetTosaMappingFromLayer_MaxPool2DLayer")
     INetworkPtr net(INetwork::Create());
 
     Pooling2dDescriptor descriptor;
-    descriptor.m_PoolType = PoolingAlgorithm::Max;
+    descriptor.m_PoolType = PoolingAlgorithm::Average;
     descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
     descriptor.m_StrideX = descriptor.m_StrideY = 2;
     descriptor.m_PadLeft = 1;
@@ -219,11 +224,11 @@ TEST_CASE("GetTosaMappingFromLayer_MaxPool2DLayer")
     descriptor.m_PadBottom = 1;
     descriptor.m_PaddingMethod = PaddingMethod::Exclude;
 
-    IConnectableLayer* input  = net->AddInputLayer(0, "input0");
-    IConnectableLayer* pool   = net->AddPooling2dLayer(descriptor, "pool");
-    IConnectableLayer* output = net->AddOutputLayer(0, "output");
+    IConnectableLayer* input0  = net->AddInputLayer(0, "input0");
+    IConnectableLayer* pool    = net->AddPooling2dLayer(descriptor, "pool");
+    IConnectableLayer* output  = net->AddOutputLayer(0, "output");
 
-    input->GetOutputSlot(0).Connect(pool->GetInputSlot(0));
+    input0->GetOutputSlot(0).Connect(pool->GetInputSlot(0));
     pool->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, DataType::Float32);
@@ -232,19 +237,24 @@ TEST_CASE("GetTosaMappingFromLayer_MaxPool2DLayer")
     std::vector<std::vector<int32_t>> inputShape  = {{ 1, 1, 4, 4 }};
     std::vector<std::vector<int32_t>> outputShape = {{ 1, 1, 3, 3 }};
 
-    input->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
+    input0->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     pool->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool));
-    AssertTosaOneToOneMappingBasicBlock(
-        basicBlock, inputShape, outputShape, Op_MAX_POOL2D, Attribute_PoolAttribute, descriptor, LayerType::Pooling2d);
+            GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool));
+    AssertTosaOneToOneMappingBasicBlock(basicBlock,
+                                        inputShape,
+                                        outputShape,
+                                        Op_AVG_POOL2D,
+                                        Attribute_PoolAttribute,
+                                        descriptor,
+                                        LayerType::Pooling2d);
 }
 
-TEST_CASE("GetTosaMapping_AvgPool2DLayer")
+TEST_CASE("GetTosaMapping_MaxPool2DLayer")
 {
     Pooling2dDescriptor descriptor;
-    descriptor.m_PoolType = PoolingAlgorithm::Average;
+    descriptor.m_PoolType = PoolingAlgorithm::Max;
     descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
     descriptor.m_StrideX = descriptor.m_StrideY = 2;
     descriptor.m_PadLeft = 1;
@@ -261,16 +271,11 @@ TEST_CASE("GetTosaMapping_AvgPool2DLayer")
 
     TosaSerializationBasicBlock* basicBlock =
         GetTosaMapping(nullptr, LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor);
-    AssertTosaOneToOneMappingBasicBlock(basicBlock,
-                                        inputShape,
-                                        outputShape,
-                                        Op_AVG_POOL2D,
-                                        Attribute_PoolAttribute,
-                                        descriptor,
-                                        LayerType::Pooling2d);
+    AssertTosaOneToOneMappingBasicBlock(
+        basicBlock, inputShape, outputShape, Op_MAX_POOL2D, Attribute_PoolAttribute, descriptor, LayerType::Pooling2d);
 }
 
-TEST_CASE("GetTosaMappingFromLayer_AvgPool2DLayer")
+TEST_CASE("GetTosaMappingFromLayer_MaxPool2DLayer")
 {
     IRuntime::CreationOptions options;
     IRuntimePtr runtime(IRuntime::Create(options));
@@ -279,7 +284,7 @@ TEST_CASE("GetTosaMappingFromLayer_AvgPool2DLayer")
     INetworkPtr net(INetwork::Create());
 
     Pooling2dDescriptor descriptor;
-    descriptor.m_PoolType = PoolingAlgorithm::Average;
+    descriptor.m_PoolType = PoolingAlgorithm::Max;
     descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
     descriptor.m_StrideX = descriptor.m_StrideY = 2;
     descriptor.m_PadLeft = 1;
@@ -288,11 +293,11 @@ TEST_CASE("GetTosaMappingFromLayer_AvgPool2DLayer")
     descriptor.m_PadBottom = 1;
     descriptor.m_PaddingMethod = PaddingMethod::Exclude;
 
-    IConnectableLayer* input0  = net->AddInputLayer(0, "input0");
-    IConnectableLayer* pool    = net->AddPooling2dLayer(descriptor, "pool");
-    IConnectableLayer* output  = net->AddOutputLayer(0, "output");
+    IConnectableLayer* input  = net->AddInputLayer(0, "input0");
+    IConnectableLayer* pool   = net->AddPooling2dLayer(descriptor, "pool");
+    IConnectableLayer* output = net->AddOutputLayer(0, "output");
 
-    input0->GetOutputSlot(0).Connect(pool->GetInputSlot(0));
+    input->GetOutputSlot(0).Connect(pool->GetInputSlot(0));
     pool->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, DataType::Float32);
@@ -301,18 +306,13 @@ TEST_CASE("GetTosaMappingFromLayer_AvgPool2DLayer")
     std::vector<std::vector<int32_t>> inputShape  = {{ 1, 1, 4, 4 }};
     std::vector<std::vector<int32_t>> outputShape = {{ 1, 1, 3, 3 }};
 
-    input0->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
+    input->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     pool->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     TosaSerializationBasicBlock* basicBlock =
         GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool));
-    AssertTosaOneToOneMappingBasicBlock(basicBlock,
-                                        inputShape,
-                                        outputShape,
-                                        Op_AVG_POOL2D,
-                                        Attribute_PoolAttribute,
-                                        descriptor,
-                                        LayerType::Pooling2d);
+    AssertTosaOneToOneMappingBasicBlock(
+        basicBlock, inputShape, outputShape, Op_MAX_POOL2D, Attribute_PoolAttribute, descriptor, LayerType::Pooling2d);
 }
 
 TEST_CASE("GetTosaMapping_ReshapeLayer")
diff --git a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
index 00c0386b51..49f2cb7319 100644
--- a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
@@ -45,36 +45,36 @@ TEST_CASE("TosaRefConv2dWithoutBiasEndtoEndTestFloat32")
     Convolution2dEndToEnd<armnn::DataType::Float32>(tosaDefaultBackends, armnn::DataLayout::NHWC, false);
 }
 
-// Max Pool 2D
-TEST_CASE("TosaRefMaxPool2DEndtoEndTestFloat32")
+// Average Pool 2D
+TEST_CASE("TosaRefAvgPool2DEndtoEndTestFloat32")
 {
-    MaxPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends);
+    AvgPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends);
 }
 
-TEST_CASE("TosaRefMaxPool2DEndtoEndTestFloat16")
+TEST_CASE("TosaRefAvgPool2DEndtoEndTestFloat16")
 {
-    MaxPool2dEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
+    AvgPool2dEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
 }
 
-TEST_CASE("TosaRefMaxPool2DIgnoreValueEndtoEndTestFloat32")
+TEST_CASE("TosaRefAvgPool2DIgnoreValueEndtoEndTestFloat32")
 {
-    MaxPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends, PaddingMethod::IgnoreValue);
+    AvgPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends, PaddingMethod::IgnoreValue);
 }
 
-// Average Pool 2D
-TEST_CASE("TosaRefAvgPool2DEndtoEndTestFloat32")
+// Max Pool 2D
+TEST_CASE("TosaRefMaxPool2DEndtoEndTestFloat32")
 {
-    AvgPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends);
+    MaxPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends);
 }
 
-TEST_CASE("TosaRefAvgPool2DEndtoEndTestFloat16")
+TEST_CASE("TosaRefMaxPool2DEndtoEndTestFloat16")
 {
-    AvgPool2dEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
+    MaxPool2dEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
 }
 
-TEST_CASE("TosaRefAvgPool2DIgnoreValueEndtoEndTestFloat32")
+TEST_CASE("TosaRefMaxPool2DIgnoreValueEndtoEndTestFloat32")
 {
-    AvgPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends, PaddingMethod::IgnoreValue);
+    MaxPool2dEndToEnd<DataType::Float32>(tosaDefaultBackends, PaddingMethod::IgnoreValue);
 }
 
 // Reshape