IVGCVSW-7168 Add Conv2d and Constant support to TOSA Reference Backend
* Added TOSA Conv2d and Constant mappings.
* Added unique naming to mappings based on previous and following
layers, so they are connected correctly.
* Updated existing mappings with new naming convention.
* Added all mappings to one main block in OptimizeSubgraphView.
* Removed isMain from mapping functions.
* Added Conv2d EndToEnd test.
Signed-off-by: Matthew Sloyan <matthew.sloyan@arm.com>
Change-Id: I27c3e238407c32379ce25a1f01dad11523ef5d2b
diff --git a/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp b/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp
index 7967977..66ca869 100644
--- a/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp
@@ -5,28 +5,36 @@
#include "AdditionOperator.hpp"
-TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const std::vector<const TensorInfo*>& inputs,
- const std::vector<const TensorInfo*>& outputs,
- bool isMain)
+TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
+ const std::vector<const TensorInfo*>& outputs)
{
- // A helper function with static global variables ensures uniqueness
- // for dynamically generating input, output and block names
- std::string input0Name = std::string("Op_ADD_input0_") + GetUniqueTosaMappingID();
- std::string input1Name = std::string("Op_ADD_input1_") + GetUniqueTosaMappingID();
- std::string outputName = std::string("Op_ADD_output0_") + GetUniqueTosaMappingID();
- std::string blockName = std::string("Op_ADD_block_") + GetUniqueTosaMappingID();
+ std::string input0Name = std::string("input0_");
+ std::string input1Name = std::string("input1_");
+ std::string outputName = std::string("output0_");
+ std::string blockName = std::string("Op_ADD_block_") + GetUniqueTosaMappingID();
- // If it's the first block, overwrite block name with main.
- if (isMain)
+ // If a layer is present then the block will be used for execution, so input and output names need to be determined
+ // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
+ if(layer != nullptr)
{
- blockName = std::string("main");
+ // Get the layers connected to the input slots and determine unique layer names.
+ Layer& connectedLayer0 = layer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer();
+ input0Name = GenerateUniqueName(connectedLayer0, 0);
+
+ Layer& connectedLayer1 = layer->GetInputSlot(1).GetConnectedOutputSlot()->GetOwningLayer();
+ input1Name = GenerateUniqueName(connectedLayer1, 1);
+
+ // Get the layer connected to the output slot and determine unique layer name.
+ Layer& connectedOutputLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+ outputName = GenerateUniqueName(connectedOutputLayer, 0);
}
- TosaSerializationOperator* op = new TosaSerializationOperator(Op_ADD,
- Attribute_NONE,
- nullptr,
- {input0Name, input1Name},
- {outputName});
+ auto* op = new TosaSerializationOperator(Op_ADD,
+ Attribute_NONE,
+ nullptr,
+ {input0Name, input1Name},
+ {outputName});
std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
@@ -37,9 +45,9 @@
std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
- TosaSerializationTensor* inputTensor0 = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
- TosaSerializationTensor* inputTensor1 = new TosaSerializationTensor(input1Name, inputShape1, inputDType1, {});
- TosaSerializationTensor* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
+ auto* inputTensor0 = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
+ auto* inputTensor1 = new TosaSerializationTensor(input1Name, inputShape1, inputDType1, {});
+ auto* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
// operatorInputNames/operatorOutputNames ends up being the same as
// blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
diff --git a/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp b/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
index f467bb6..5eb7441 100644
--- a/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
+++ b/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
@@ -5,15 +5,16 @@
#pragma once
+#include "TosaOperatorUtils.hpp"
+
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
-#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
-TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const std::vector<const TensorInfo*>& inputs,
- const std::vector<const TensorInfo*>& outputs,
- bool isMain);
+TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
+ const std::vector<const TensorInfo*>& outputs);
diff --git a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp
index b3d2687..2601a62 100644
--- a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp
@@ -5,23 +5,27 @@
#include "Pooling2DOperator.hpp"
-TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
const std::vector<const TensorInfo*>& outputs,
- bool isMain,
const Pooling2dDescriptor* poolDescriptor)
{
+ std::string padInputName = std::string("input0_");
+ std::string padOutputName = std::string("intermediate0_") + GetUniqueTosaMappingID();
+ std::string poolOutputName = std::string("output0_");
+ std::string blockName = std::string("Op_AVG_POOL2D_block_") + GetUniqueTosaMappingID();
- // A helper function with static global variables ensures uniqueness
- // for dynamically generating input, output and block names
- std::string padInputName = std::string("Op_PAD_input0_") + GetUniqueTosaMappingID();
- std::string padOutputName = std::string("Op_PAD_intermediate0_") + GetUniqueTosaMappingID();
- std::string poolOutputName = std::string("Op_AVG_POOL2D_output0_") + GetUniqueTosaMappingID();
- std::string blockName = std::string("Op_AVG_POOL2D_block_") + GetUniqueTosaMappingID();
-
- // If it's the first block, overwrite block name with main.
- if (isMain)
+ // If a layer is present then the block will be used for execution, so input and output names need to be determined
+ // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
+ if(layer != nullptr)
{
- blockName = std::string("main");
+ // Get the layers connected to the input slots and determine unique layer names.
+ Layer& connectedInputLayer = layer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer();
+ padInputName = GenerateUniqueName(connectedInputLayer, 0);
+
+ // Get the layer connected to the output slot and determine unique layer name.
+ Layer& connectedOutputLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+ poolOutputName = GenerateUniqueName(connectedOutputLayer, 0);
}
std::vector<int> paddings;
@@ -51,11 +55,11 @@
}
TosaPadAttribute padAttribute(paddings, 0, 0.0f);
- TosaSerializationOperator* opPad = new TosaSerializationOperator(Op_PAD,
- Attribute_PadAttribute,
- &padAttribute,
- {padInputName},
- {padOutputName});
+ auto* opPad = new TosaSerializationOperator(Op_PAD,
+ Attribute_PadAttribute,
+ &padAttribute,
+ {padInputName},
+ {padOutputName});
std::vector<int> pad = {0, 0, 0, 0};
std::vector<int> kernel = {static_cast<int>(poolDescriptor->m_PoolHeight),
@@ -64,11 +68,11 @@
static_cast<int>(poolDescriptor->m_StrideX)};
TosaPoolAttribute poolAttribute(pad, kernel, stride, 0, 0, ArmNNToDType(inputs[0]->GetDataType()));
- TosaSerializationOperator* opPool = new TosaSerializationOperator(Op_AVG_POOL2D,
- Attribute_PoolAttribute,
- &poolAttribute,
- {padOutputName},
- {poolOutputName});
+ auto* opPool = new TosaSerializationOperator(Op_AVG_POOL2D,
+ Attribute_PoolAttribute,
+ &poolAttribute,
+ {padOutputName},
+ {poolOutputName});
std::vector<int32_t> inputShape = GetTosaTensorShape(inputs[0]->GetShape());
DType inputDType = ArmNNToDType(inputs[0]->GetDataType());
@@ -92,10 +96,9 @@
inputShape[3] + paddings[6] + paddings[7]};
}
- TosaSerializationTensor* inputTensor = new TosaSerializationTensor(padInputName, inputShape, inputDType, {});
- TosaSerializationTensor* intermediateTensor = new TosaSerializationTensor(
- padOutputName, intermediateShape, inputDType, {});
- TosaSerializationTensor* outputTensor = new TosaSerializationTensor(poolOutputName, outputShape, outputDType, {});
+ auto* inputTensor = new TosaSerializationTensor(padInputName, inputShape, inputDType, {});
+ auto* intermediateTensor = new TosaSerializationTensor(padOutputName, intermediateShape, inputDType, {});
+ auto* outputTensor = new TosaSerializationTensor(poolOutputName, outputShape, outputDType, {});
// operatorInputNames/operatorOutputNames ends up being the same as
// blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
diff --git a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp
index 63ae190..f9d0975 100644
--- a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp
+++ b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp
@@ -5,15 +5,16 @@
#pragma once
+#include "TosaOperatorUtils.hpp"
+
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
-#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
-TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
const std::vector<const TensorInfo*>& outputs,
- bool isMain,
const Pooling2dDescriptor* poolDescriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/CMakeLists.txt b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
index 7fdc922..b256edd 100644
--- a/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
+++ b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
@@ -8,6 +8,10 @@
AdditionOperator.cpp
AvgPool2DIgnoreValueOperator.hpp
AvgPool2DIgnoreValueOperator.cpp
+ ConstantOperator.hpp
+ ConstantOperator.cpp
+ Conv2dOperator.hpp
+ Conv2dOperator.cpp
Pooling2DOperator.hpp
Pooling2DOperator.cpp
TosaOperatorUtils.hpp
diff --git a/src/backends/tosaCommon/operatorMappings/ConstantOperator.cpp b/src/backends/tosaCommon/operatorMappings/ConstantOperator.cpp
new file mode 100644
index 0000000..5e3973f
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/ConstantOperator.cpp
@@ -0,0 +1,44 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ConstantOperator.hpp"
+
+#include <layers/ConstantLayer.hpp>
+
+TosaSerializationBasicBlock* ConvertConstantToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& outputs)
+{
+ std::string outputName = std::string("constant_");
+ std::string blockName = std::string("Op_CONST_block_") + GetUniqueTosaMappingID();
+
+ std::vector<uint8_t> uint8Data;
+
+ // If a layer is present then the block will be used for execution, so names need to be unique.
+ // Also, set constant tensor data.
+ if(layer != nullptr)
+ {
+ outputName.append(std::to_string(layer->GetGuid()));
+ blockName.append(std::to_string(layer->GetGuid()));
+
+ auto constantLayer = PolymorphicDowncast<const armnn::ConstantLayer*>(layer);
+ auto tensorInfo = constantLayer->GetOutputSlot().GetTensorInfo();
+
+ uint8Data = ConvertConstantTensorDataToBuffer(constantLayer->m_LayerOutput);
+ }
+
+ auto* op = new TosaSerializationOperator(Op_CONST, Attribute_NONE, nullptr, {}, {outputName});
+
+ std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
+ DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
+
+ // Setup output tensor with constant tensor data if available.
+ auto* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, uint8Data);
+
+ return new TosaSerializationBasicBlock(blockName, // name
+ {op}, // operators
+ {outputTensor0}, // tensors
+ {}, // inputs
+ {outputName}); // outputs
+}
\ No newline at end of file
diff --git a/src/backends/tosaCommon/operatorMappings/ConstantOperator.hpp b/src/backends/tosaCommon/operatorMappings/ConstantOperator.hpp
new file mode 100644
index 0000000..df158ac
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/ConstantOperator.hpp
@@ -0,0 +1,19 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "TosaOperatorUtils.hpp"
+
+#include <Layer.hpp>
+
+#include <tosa_serialization_handler.h>
+
+using namespace armnn;
+using namespace tosa;
+
+TosaSerializationBasicBlock* ConvertConstantToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& outputs);
+
diff --git a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
new file mode 100644
index 0000000..9c095d6
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
@@ -0,0 +1,123 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "Conv2dOperator.hpp"
+
+TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
+ const std::vector<const TensorInfo*>& outputs,
+ const Convolution2dDescriptor* conv2dDescriptor)
+{
+ std::vector<std::string> inputNames;
+ std::string outputName = std::string("output0_");
+ std::string blockName = std::string("Op_CONV2D_block_") + GetUniqueTosaMappingID();
+
+ // Set input names for validation purposes only.
+ if(layer == nullptr)
+ {
+ inputNames.emplace_back("input0_");
+ inputNames.emplace_back("input1_");
+ if(conv2dDescriptor->m_BiasEnabled)
+ {
+ inputNames.emplace_back("input2_");
+ }
+ }
+ else
+ {
+ // If a layer is present then the block will be used for execution, so input and output names need to be
+ // determined using the previous and following layers so the graph is connected correctly.
+ // For validation this doesn't matter.
+ for (uint32_t i = 0; i < inputs.size(); ++i)
+ {
+ // Get the layer connected to the input slot and determine unique layer name.
+ Layer& connectedLayer = layer->GetInputSlot(i).GetConnectedOutputSlot()->GetOwningLayer();
+
+ std::string inputName = GenerateUniqueName(connectedLayer, i);
+ inputNames.push_back(inputName);
+ }
+
+ // Get the layer connected to the output slot and determine unique layer name.
+ Layer& connectedLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+
+ outputName = GenerateUniqueName(connectedLayer, 0);
+ }
+
+ std::vector<TosaSerializationTensor*> tensors;
+ std::vector<TosaSerializationOperator*> operators;
+
+ // Setup input Tensor
+ std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
+ DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
+
+ tensors.push_back(new TosaSerializationTensor(inputNames[0], inputShape0, inputDType0, {}));
+
+ // Only add input tensors if weights and bias are not constant or if running validation.
+ // Constant tensors will be created in the ConvertConstantToTosaOperator function.
+ if(!inputs[1]->IsConstant() || layer == nullptr)
+ {
+ std::vector<int32_t> inputShape1 = GetTosaTensorShape(inputs[1]->GetShape());
+ DType inputDType1 = ArmNNToDType(inputs[1]->GetDataType());
+
+ tensors.push_back(new TosaSerializationTensor(inputNames[1], inputShape1, inputDType1, {}));
+ }
+
+ if(conv2dDescriptor->m_BiasEnabled)
+ {
+ if(!inputs[2]->IsConstant() || layer == nullptr)
+ {
+ std::vector<int32_t> inputShape2 = GetTosaTensorShape(inputs[2]->GetShape());
+ DType inputDType2 = ArmNNToDType(inputs[2]->GetDataType());
+
+ tensors.push_back(new TosaSerializationTensor(inputNames[2], inputShape2, inputDType2, {}));
+ }
+ }
+ else
+ {
+ // If bias is disabled, create a constant bias of 0 as three inputs are required.
+ std::string constantName = std::string("constant_") + GetUniqueTosaMappingID();
+
+ operators.push_back(new TosaSerializationOperator(Op_CONST, Attribute_NONE, nullptr, {}, {constantName}));
+
+ std::vector<uint8_t> uint8Data;
+ std::vector<float> data = { 0.0 };
+
+ TosaSerializationHandler::ConvertF32toU8(data, uint8Data);
+
+ tensors.push_back(new TosaSerializationTensor(constantName, {1}, DType_FP32, uint8Data));
+ inputNames.emplace_back(constantName);
+ }
+
+ // Setup Output Tensor
+ std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
+ DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
+
+ tensors.push_back(new TosaSerializationTensor(outputName, outputShape0, outputDType0, {}));
+
+ // Set up CONV2D operator
+ std::vector<int> pad = {static_cast<int>(conv2dDescriptor->m_PadTop),
+ static_cast<int>(conv2dDescriptor->m_PadBottom),
+ static_cast<int>(conv2dDescriptor->m_PadLeft),
+ static_cast<int>(conv2dDescriptor->m_PadRight)};
+ std::vector<int> stride = {static_cast<int>(conv2dDescriptor->m_StrideY),
+ 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()));
+
+ auto* op = new TosaSerializationOperator(Op_CONV2D,
+ Attribute_ConvAttribute,
+ &attribute,
+ inputNames,
+ {outputName});
+ operators.push_back(op);
+
+ // operatorInputNames/operatorOutputNames ends up being the same as
+ // blockInputNames/blockOutputNames for one-to-one ArmNN to TOSA mappings
+ return new TosaSerializationBasicBlock(blockName, // name
+ operators, // operators
+ tensors, // tensors
+ inputNames, // inputs
+ {outputName}); // outputs
+}
\ No newline at end of file
diff --git a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.hpp b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.hpp
new file mode 100644
index 0000000..909151b
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.hpp
@@ -0,0 +1,20 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "TosaOperatorUtils.hpp"
+
+#include <Layer.hpp>
+
+#include <tosa_serialization_handler.h>
+
+using namespace armnn;
+using namespace tosa;
+
+TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
+ const std::vector<const TensorInfo*>& outputs,
+ const Convolution2dDescriptor* conv2dDescriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp
index cd707ed..eaeb8a4 100644
--- a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp
@@ -5,24 +5,29 @@
#include "Pooling2DOperator.hpp"
-TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
const std::vector<const TensorInfo*>& outputs,
- bool isMain,
const Pooling2dDescriptor* poolDescriptor)
{
std::string poolType = (poolDescriptor->m_PoolType == PoolingAlgorithm::Max) ? "Op_MAX" : "Op_AVG";
Op opcode = (poolDescriptor->m_PoolType == PoolingAlgorithm::Max) ? Op_MAX_POOL2D : Op_AVG_POOL2D;
- // A helper function with static global variables ensures uniqueness
- // for dynamically generating input, output and block names
- std::string input0Name = poolType + std::string("_POOL2D_input0_") + GetUniqueTosaMappingID();
- std::string outputName = poolType + std::string("_POOL2D_output0_") + GetUniqueTosaMappingID();
- std::string blockName = poolType + std::string("_POOL2D_block_") + GetUniqueTosaMappingID();
+ std::string input0Name = std::string("input0_");
+ std::string outputName = std::string("output0_");
+ std::string blockName = std::string("Op_") + poolType + std::string("_POOL2D_block_") + GetUniqueTosaMappingID();
- // If it's the first block, overwrite block name with main.
- if (isMain)
+ // If a layer is present then the block will be used for execution, so input and output names need to be determined
+ // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
+ if(layer != nullptr)
{
- blockName = std::string("main");
+ // Get the layers connected to the input slots and determine unique layer names.
+ Layer& connectedInputLayer = layer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer();
+ input0Name = GenerateUniqueName(connectedInputLayer, 0);
+
+ // Get the layer connected to the output slot and determine unique layer name.
+ Layer& connectedOutputLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+ outputName = GenerateUniqueName(connectedOutputLayer, 0);
}
std::vector<int> pad = {static_cast<int>(poolDescriptor->m_PadTop),
@@ -35,11 +40,11 @@
static_cast<int>(poolDescriptor->m_StrideX)};
TosaPoolAttribute attribute(pad, kernel, stride, 0, 0, ArmNNToDType(inputs[0]->GetDataType()));
- TosaSerializationOperator* op = new TosaSerializationOperator(opcode,
- Attribute_PoolAttribute,
- &attribute,
- {input0Name},
- {outputName});
+ auto* op = new TosaSerializationOperator(opcode,
+ Attribute_PoolAttribute,
+ &attribute,
+ {input0Name},
+ {outputName});
std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
@@ -47,8 +52,8 @@
std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
- TosaSerializationTensor* inputTensor0 = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
- TosaSerializationTensor* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
+ auto* inputTensor0 = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
+ auto* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
// operatorInputNames/operatorOutputNames ends up being the same as
// blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
diff --git a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp
index 22d2a3a..cc9ec09 100644
--- a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp
+++ b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp
@@ -5,15 +5,16 @@
#pragma once
+#include "TosaOperatorUtils.hpp"
+
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
-#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
-TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const Layer* layer,
+ const std::vector<const TensorInfo*>& inputs,
const std::vector<const TensorInfo*>& outputs,
- bool isMain,
const Pooling2dDescriptor* poolDescriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp b/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
index 00b5f0f..513db0c 100644
--- a/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
+++ b/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
@@ -6,5 +6,7 @@
#pragma once
#include "AdditionOperator.hpp"
+#include "ConstantOperator.hpp"
+#include "Conv2dOperator.hpp"
#include "AvgPool2DIgnoreValueOperator.hpp"
#include "Pooling2DOperator.hpp"
\ No newline at end of file
diff --git a/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
index f51b210..176e4e1 100644
--- a/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
+++ b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
@@ -5,10 +5,13 @@
#pragma once
+#include <Layer.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
-#include <tosa_generated.h>
+#include "common/include/ProfilingGuid.hpp"
+
+#include <tosa_serialization_handler.h>
using namespace armnn;
using namespace tosa;
@@ -53,6 +56,33 @@
return returnShape;
}
+// Function that generates unique name using the layer type, input slot and layer guid.
+inline std::string GenerateUniqueName(const Layer& layer, uint32_t layerSlot)
+{
+ std::string name;
+ std::string guid = std::to_string(layer.GetGuid());
+ std::string slotAndGuid = std::to_string(layerSlot) + "_" + guid;
+ LayerType layerType = layer.GetType();
+
+ if (layerType == LayerType::Input)
+ {
+ name = "input" + slotAndGuid;
+ }
+ else if (layerType == LayerType::Output)
+ {
+ name = "output" + slotAndGuid;
+ }
+ else if (layerType == LayerType::Constant)
+ {
+ name = "constant_" + guid;
+ }
+ else
+ {
+ name = "intermediate" + slotAndGuid;
+ }
+ return name;
+}
+
// Function to return unique int as a string to ensure uniqueness between all input, output and block names.
static int uniqueTosaMappingID = 0;
inline std::string GetUniqueTosaMappingID()
@@ -206,3 +236,72 @@
}
return "";
}
+
+inline std::vector<uint8_t> ConvertConstantTensorDataToBuffer(const std::shared_ptr<ConstTensorHandle>& tensorHandle)
+{
+ tosa_err_t error;
+ std::vector<uint8_t> uint8Data;
+ auto tensorInfo = tensorHandle->GetTensorInfo();
+
+ switch (tensorInfo.GetDataType())
+ {
+ case DataType::Float32:
+ {
+ std::vector<float> data(tensorInfo.GetNumElements());
+ memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+ error = TosaSerializationHandler::ConvertF32toU8(data, uint8Data);
+ break;
+ }
+ case DataType::Float16:
+ {
+ std::vector<float> data(tensorInfo.GetNumElements());
+ memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+ error = TosaSerializationHandler::ConvertF16toU8(data, uint8Data);
+ break;
+ }
+ case DataType::QSymmS8:
+ case DataType::QAsymmS8:
+ {
+ std::vector<int8_t> data(tensorInfo.GetNumElements());
+ memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+ error = TosaSerializationHandler::ConvertI8toU8(data, uint8Data);
+ break;
+ }
+ case DataType::QAsymmU8:
+ {
+ memcpy(uint8Data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+ break;
+ }
+ case DataType::QSymmS16:
+ {
+ std::vector<int16_t> data(tensorInfo.GetNumElements());
+ memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+ error = TosaSerializationHandler::ConvertI16toU8(data, uint8Data);
+ break;
+ }
+ case DataType::Signed32:
+ {
+ std::vector<int32_t> data(tensorInfo.GetNumElements());
+ memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+ error = TosaSerializationHandler::ConvertI32toU8(data, uint8Data);
+ break;
+ }
+ default:
+ {
+ throw armnn::Exception("SetConstantTensorData: An unsupported data type was encountered.");
+ }
+ }
+
+ if(error != tosa_err_t::TOSA_OK)
+ {
+ throw armnn::Exception("SetConstantTensorData: An error occurred when converting constant data");
+ }
+
+ tensorHandle->Unmap();
+ return uint8Data;
+}