src/backends/tosaReference/TosaRefLayerSupport.cpp - ml/armnn - Gitiles

 //
 // Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //

 #include "TosaRefLayerSupport.hpp"
 #include <tosaCommon/TosaMappings.hpp>

 #include <armnn/Types.hpp>
 #include <armnn/utility/IgnoreUnused.hpp>
 #include <tosaCommon/TosaLayerSupportRules.hpp>
 #include <LayerSupportCommon.hpp>

 #include <vector>
 #include <array>
 #include <tuple>

 namespace armnn
 {

 static bool RunTosaLayerChecksSingleDataType(TosaSerializationOperator* op,
                                              const std::vector<TosaSerializationTensor*>& inputs,
                                              const std::vector<TosaSerializationTensor*>& outputs,
                                              const std::vector<Attribute>& supportedAttributes,
                                              const std::vector<DType>& supportedTypes,
                                              Optional<string&> reasonIfUnsupported)
 {
     bool supported = true;

     std::string opString = TosaOpToString(op->GetOp());

     // Check Attribute from operator (GetAttribute)
     supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
                                   std::string("TOSA Reference Operator: " + opString +
                                               " has an unsupported attribute.").c_str());

     for (auto input : inputs)
     {
         std::string dataTypeCode = std::to_string(input->GetDtype());

         // Check Dtype from tensor (GetDtype)
         supported &= CheckSupportRule(TosaTypeAnyOf(input, supportedTypes),
                                       reasonIfUnsupported,
                                       std::string("TOSA Reference Operator: " + opString + " for input: " +
                                                   input->GetName() + " has an unsupported data type: " +
                                                   dataTypeCode).c_str());

         // Check Shape from tensor (GetShape)
         supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input),
                                       reasonIfUnsupported,
                                       std::string("Tosa Reference Operator: " + opString + " for input: " +
                                                   input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
     }

     for (auto output : outputs)
     {
         std::string dataTypeCode = std::to_string(output->GetDtype());

         // Check Dtype from tensor (GetDtype)
         supported &= CheckSupportRule(TosaTypeAnyOf(output, supportedTypes),
                                       reasonIfUnsupported,
                                       std::string("TOSA Reference Operator: " + opString + " for output: " +
                                                   output->GetName() + " has an unsupported data type: " +
                                                   dataTypeCode).c_str());

         // Check Shape from tensor (GetShape)
         supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output),
                                       reasonIfUnsupported,
                                       std::string("Tosa Reference Operator: " + opString + " for output: " +
                                                   output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
     }

     return supported;
 }

 static bool RunTosaLayerChecksInputOutputDataType(TosaSerializationOperator* op,
                                                   const std::vector<TosaSerializationTensor*>& inputs,
                                                   const std::vector<TosaSerializationTensor*>& outputs,
                                                   const std::vector<Attribute>& supportedAttributes,
                                                   const std::vector<std::tuple<DType,DType>>& supportedMappingTypes,
                                                   Optional<string&> reasonIfUnsupported)
 {
     bool supported = true;

     std::string opString = TosaOpToString(op->GetOp());

     // Check Attribute from operator (GetAttribute)
     supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
                                   std::string("TOSA Reference Operator: " + opString +
                                       " has an unsupported attribute.").c_str());

     supported &= CheckSupportRule(TosaAssertSize(inputs, outputs), reasonIfUnsupported,
                                   std::string("TOSA Reference Operator: " + opString +
                                       " must have 1-to-1 mapping of inputs-to-outputs.").c_str());

     for (uint32_t i = 0; i < inputs.size(); i++)
     {
         auto input = inputs[i];
         auto output = outputs[i];
         std::string inputDataTypeCode = std::to_string(input->GetDtype());
         std::string outputDataTypeCode = std::to_string(output->GetDtype());
         std::tuple<DType, DType> mappingType(input->GetDtype(), output->GetDtype());

         // Check Dtype from tensor (GetDtype)
         supported &= CheckSupportRule(TosaContainerContainsTwoTypes(mappingType, supportedMappingTypes),
                                       reasonIfUnsupported,
                                       std::string("TOSA Reference Operator: " + opString + " for input: " +
                                           input->GetName() + " and output: " + output->GetName() +
                                           " has an unsupported input data type: " + inputDataTypeCode +
                                           " to output data type: " + outputDataTypeCode).c_str());

         // Check Shape from tensor (GetShape)
         supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input),
                                       reasonIfUnsupported,
                                       std::string("Tosa Reference Operator: " + opString + " for input: " +
                                           input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());

         // Check Shape from tensor (GetShape)
         supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output),
                                       reasonIfUnsupported,
                                       std::string("Tosa Reference Operator: " + opString + " for output: " +
                                           output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
     }

     return supported;
 }

 static bool RunTosaLayerChecksInputWeightsOutputDataType(
         TosaSerializationOperator* op,
         const std::vector<TosaSerializationTensor*>& inputs,
         const std::vector<TosaSerializationTensor*>& outputs,
         const std::vector<Attribute>& supportedAttributes,
         const std::vector<std::tuple<DType, DType, DType>>& supportedMappingTypes,
         Optional<string&> reasonIfUnsupported)
 {
     bool supported = true;

     std::string opString = TosaOpToString(op->GetOp());

     // Check Attribute from operator (GetAttribute)
     supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
                                   std::string("TOSA Reference Operator: " + opString +
                                               " has an unsupported attribute.").c_str());

     // Check combination of input, weights and output types.
     // Bias is the same as output type, so it is covered.
     std::tuple<DType, DType, DType> mappingTypes(inputs[0]->GetDtype(), inputs[1]->GetDtype(), outputs[0]->GetDtype());

     // Check Dtype from tensor (GetDtype)
     supported &= CheckSupportRule(TosaContainerContainsThreeTypes(mappingTypes, supportedMappingTypes),
                                   reasonIfUnsupported,
                                   std::string("TOSA Reference Operator: " + opString + " for input 0: " +
                                               inputs[0]->GetName() + ", input 1: " + inputs[1]->GetName() +
                                               " and output: " + outputs[0]->GetName() +
                                               " has an unsupported input data type combination.").c_str());

     for (auto input : inputs)
     {
         // Check Shape from tensor (GetShape)
         supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input),
                                       reasonIfUnsupported,
                                       std::string("Tosa Reference Operator: " + opString + " for input: " +
                                                   input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
     }

     for (auto output : outputs)
     {
         // Check Shape from tensor (GetShape)
         supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output),
                                       reasonIfUnsupported,
                                       std::string("Tosa Reference Operator: " + opString + " for output: " +
                                                   output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
     }

     return supported;
 }


 static bool IsTosaLayerSupported(TosaSerializationOperator* op,
                                  const std::vector<TosaSerializationTensor*>& inputs,
                                  const std::vector<TosaSerializationTensor*>& outputs,
                                  Optional<string&> reasonIfUnsupported)
 {
     switch(op->GetOp())
     {
         case tosa::Op_ADD:
         {
             std::vector<Attribute> supportedAttributes = { Attribute_NONE };

             // Only Int32, Fp32 and Fp16 are currently supported by the TOSA Reference Model.
             std::vector<DType> supportedTypes =
             {
                 DType_INT32,
                 DType_FP16,
                 DType_FP32
             };

             // Check the attribute, data types and bounds for inputs and outputs.
             return RunTosaLayerChecksSingleDataType(
                     op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
         }
         case tosa::Op_CONST:
         {
             std::vector<Attribute> supportedAttributes = { Attribute_NONE };

             std::vector<DType> supportedTypes =
             {
                 DType_FP16,
                 DType_FP32,
                 DType_UINT8,
                 DType_INT8,
                 DType_INT16,
                 DType_INT32,
                 DType_BOOL
             };

             // Check the attribute, data types and bounds for inputs and outputs.
             return RunTosaLayerChecksSingleDataType(
                     op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
         }
         case tosa::Op_CONV2D:
         {
             std::vector<Attribute> supportedAttributes = { Attribute_ConvAttribute };

             std::vector<std::tuple<DType, DType, DType>> supportedTypesMapping =
             {
                 std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP16),
                 std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP32),
                 std::tuple<DType, DType, DType>(DType_FP32, DType_FP32, DType_FP32),
                 std::tuple<DType, DType, DType>(DType_INT8, DType_INT8, DType_INT32)
             };

             return RunTosaLayerChecksInputWeightsOutputDataType(
                     op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported);
         }
         case tosa::Op_AVG_POOL2D:
         {
             std::vector<Attribute> supportedAttributes = { Attribute_PoolAttribute };

             std::vector<std::tuple<DType, DType>> supportedTypesMapping =
             {
                 std::tuple<DType, DType>(DType_FP16, DType_FP16),
                 std::tuple<DType, DType>(DType_FP16, DType_FP32),
                 std::tuple<DType, DType>(DType_FP32, DType_FP32),
                 std::tuple<DType, DType>(DType_INT8, DType_INT32),
                 std::tuple<DType, DType>(DType_INT16, DType_INT32)
             };

             // Check the attribute, data types and bounds for inputs and outputs.
             return RunTosaLayerChecksInputOutputDataType(
                     op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported);
         }
         case tosa::Op_MAX_POOL2D:
         {
             std::vector<Attribute> supportedAttributes = { Attribute_PoolAttribute };

             std::vector<DType> supportedTypes =
             {
                 DType_FP16,
                 DType_FP32,
                 DType_INT8,
                 DType_INT16
             };

             // Check the attribute, data types and bounds for inputs and outputs.
             return RunTosaLayerChecksSingleDataType(
                     op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
         }
         case tosa::Op_PAD:
         {
             std::vector<Attribute> supportedAttributes = { Attribute_PadAttribute };

             std::vector<DType> supportedTypes =
             {
                 DType_FP16,
                 DType_FP32,
                 DType_INT8,
                 DType_INT16,
                 DType_INT32,
                 DType_BOOL
             };

             // Check the attribute, data types and bounds for inputs and outputs.
             return RunTosaLayerChecksSingleDataType(
                     op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
         }
         default:
             SetValueChecked(reasonIfUnsupported, "Operation is currently unsupported by the TOSA Reference Backend.");
             return false;
     }
 }

 bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type,
                                            const std::vector<TensorInfo>& infos,
                                            const BaseDescriptor& descriptor,
                                            const Optional<LstmInputParamsInfo>& lstmParamsInfo,
                                            const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmInputParamsInfo,
                                            Optional<std::string&> reasonIfUnsupported) const
 {
     IgnoreUnused(lstmParamsInfo);
     IgnoreUnused(quantizedLstmInputParamsInfo);

     std::vector<const TensorInfo*> inputInfos;
     std::vector<const TensorInfo*> outputInfos;

     switch (type)
     {
         case LayerType::Input:
         case LayerType::Output:
             return true;
         case LayerType::Addition:
             // Setup inputs and outputs
             inputInfos.push_back(&infos[0]);
             inputInfos.push_back(&infos[1]);
             outputInfos.push_back(&infos[2]);
             break;
         case LayerType::Constant:
             outputInfos.push_back(&infos[0]);
             break;
         case LayerType::Convolution2d:
         {
             inputInfos.push_back(&infos[0]); // input
             outputInfos.push_back(&infos[1]); // output
             inputInfos.push_back(&infos[2]); // weights

             auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
             if(conv2dDesc->m_BiasEnabled)
             {
                 inputInfos.push_back(&infos[3]); // bias
             }
             break;
         }
         case LayerType::Pooling2d:
             // Setup inputs and outputs
             inputInfos.push_back(&infos[0]);
             outputInfos.push_back(&infos[1]);
             break;
         default:
             break;
     }

     auto mappings = GetTosaMapping(nullptr, type, inputInfos, outputInfos, descriptor);
     if (mappings->GetName() == "")
     {
         // There currently isn't a TOSA mapping for this layer, as the default was returned.
         return false;
     }

     // Loop through block and get each tensor and operator
     for (long unsigned int i = 0; i < mappings->GetOperators().size(); ++i)
     {
         // While looping over operators check for op_UNKNOWN which is unsupported
         if (mappings->GetOperators()[i]->GetOp() == tosa::Op_UNKNOWN) { return false; }

         // Loop over operators and get GetInput/OutputTensorNames, loop over resulting names and
         // use GetTensorByName to pass pointers to tensors on to the IsTosaLayerSupported()
         std::vector<TosaSerializationTensor*> inputTensorsVect;
         for (const auto& name : mappings->GetOperators()[i]->GetInputTensorNames())
         {
             inputTensorsVect.push_back(mappings->GetTensorByName(name));
         }

         std::vector<TosaSerializationTensor*> outputTensorsVect;
         for (const auto& name : mappings->GetOperators()[i]->GetOutputTensorNames())
         {
             outputTensorsVect.push_back(mappings->GetTensorByName(name));
         }

         if (!IsTosaLayerSupported(mappings->GetOperators()[i],
                                   inputTensorsVect,
                                   outputTensorsVect,
                                   reasonIfUnsupported))
         {
             return false;
         }
     }
     return true;
 }

 } // namespace armnn
	//
	// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
	// SPDX-License-Identifier: MIT
	//

	#include "TosaRefLayerSupport.hpp"
	#include <tosaCommon/TosaMappings.hpp>

	#include <armnn/Types.hpp>
	#include <armnn/utility/IgnoreUnused.hpp>
	#include <tosaCommon/TosaLayerSupportRules.hpp>
	#include <LayerSupportCommon.hpp>

	#include <vector>
	#include <array>
	#include <tuple>

	namespace armnn
	{

	static bool RunTosaLayerChecksSingleDataType(TosaSerializationOperator* op,
	const std::vector<TosaSerializationTensor*>& inputs,
	const std::vector<TosaSerializationTensor*>& outputs,
	const std::vector<Attribute>& supportedAttributes,
	const std::vector<DType>& supportedTypes,
	Optional<string&> reasonIfUnsupported)
	{
	bool supported = true;

	std::string opString = TosaOpToString(op->GetOp());

	// Check Attribute from operator (GetAttribute)
	supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString +
	" has an unsupported attribute.").c_str());

	for (auto input : inputs)
	{
	std::string dataTypeCode = std::to_string(input->GetDtype());

	// Check Dtype from tensor (GetDtype)
	supported &= CheckSupportRule(TosaTypeAnyOf(input, supportedTypes),
	reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString + " for input: " +
	input->GetName() + " has an unsupported data type: " +
	dataTypeCode).c_str());

	// Check Shape from tensor (GetShape)
	supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input),
	reasonIfUnsupported,
	std::string("Tosa Reference Operator: " + opString + " for input: " +
	input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
	}

	for (auto output : outputs)
	{
	std::string dataTypeCode = std::to_string(output->GetDtype());

	// Check Dtype from tensor (GetDtype)
	supported &= CheckSupportRule(TosaTypeAnyOf(output, supportedTypes),
	reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString + " for output: " +
	output->GetName() + " has an unsupported data type: " +
	dataTypeCode).c_str());

	// Check Shape from tensor (GetShape)
	supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output),
	reasonIfUnsupported,
	std::string("Tosa Reference Operator: " + opString + " for output: " +
	output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
	}

	return supported;
	}

	static bool RunTosaLayerChecksInputOutputDataType(TosaSerializationOperator* op,
	const std::vector<TosaSerializationTensor*>& inputs,
	const std::vector<TosaSerializationTensor*>& outputs,
	const std::vector<Attribute>& supportedAttributes,
	const std::vector<std::tuple<DType,DType>>& supportedMappingTypes,
	Optional<string&> reasonIfUnsupported)
	{
	bool supported = true;

	std::string opString = TosaOpToString(op->GetOp());

	// Check Attribute from operator (GetAttribute)
	supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString +
	" has an unsupported attribute.").c_str());

	supported &= CheckSupportRule(TosaAssertSize(inputs, outputs), reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString +
	" must have 1-to-1 mapping of inputs-to-outputs.").c_str());

	for (uint32_t i = 0; i < inputs.size(); i++)
	{
	auto input = inputs[i];
	auto output = outputs[i];
	std::string inputDataTypeCode = std::to_string(input->GetDtype());
	std::string outputDataTypeCode = std::to_string(output->GetDtype());
	std::tuple<DType, DType> mappingType(input->GetDtype(), output->GetDtype());

	// Check Dtype from tensor (GetDtype)
	supported &= CheckSupportRule(TosaContainerContainsTwoTypes(mappingType, supportedMappingTypes),
	reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString + " for input: " +
	input->GetName() + " and output: " + output->GetName() +
	" has an unsupported input data type: " + inputDataTypeCode +
	" to output data type: " + outputDataTypeCode).c_str());

	// Check Shape from tensor (GetShape)
	supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input),
	reasonIfUnsupported,
	std::string("Tosa Reference Operator: " + opString + " for input: " +
	input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());

	// Check Shape from tensor (GetShape)
	supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output),
	reasonIfUnsupported,
	std::string("Tosa Reference Operator: " + opString + " for output: " +
	output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
	}

	return supported;
	}

	static bool RunTosaLayerChecksInputWeightsOutputDataType(
	TosaSerializationOperator* op,
	const std::vector<TosaSerializationTensor*>& inputs,
	const std::vector<TosaSerializationTensor*>& outputs,
	const std::vector<Attribute>& supportedAttributes,
	const std::vector<std::tuple<DType, DType, DType>>& supportedMappingTypes,
	Optional<string&> reasonIfUnsupported)
	{
	bool supported = true;

	std::string opString = TosaOpToString(op->GetOp());

	// Check Attribute from operator (GetAttribute)
	supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString +
	" has an unsupported attribute.").c_str());

	// Check combination of input, weights and output types.
	// Bias is the same as output type, so it is covered.
	std::tuple<DType, DType, DType> mappingTypes(inputs[0]->GetDtype(), inputs[1]->GetDtype(), outputs[0]->GetDtype());

	// Check Dtype from tensor (GetDtype)
	supported &= CheckSupportRule(TosaContainerContainsThreeTypes(mappingTypes, supportedMappingTypes),
	reasonIfUnsupported,
	std::string("TOSA Reference Operator: " + opString + " for input 0: " +
	inputs[0]->GetName() + ", input 1: " + inputs[1]->GetName() +
	" and output: " + outputs[0]->GetName() +
	" has an unsupported input data type combination.").c_str());

	for (auto input : inputs)
	{
	// Check Shape from tensor (GetShape)
	supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input),
	reasonIfUnsupported,
	std::string("Tosa Reference Operator: " + opString + " for input: " +
	input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
	}

	for (auto output : outputs)
	{
	// Check Shape from tensor (GetShape)
	supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output),
	reasonIfUnsupported,
	std::string("Tosa Reference Operator: " + opString + " for output: " +
	output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
	}

	return supported;
	}



	static bool IsTosaLayerSupported(TosaSerializationOperator* op,
	const std::vector<TosaSerializationTensor*>& inputs,
	const std::vector<TosaSerializationTensor*>& outputs,
	Optional<string&> reasonIfUnsupported)
	{
	switch(op->GetOp())
	{
	case tosa::Op_ADD:
	{
	std::vector<Attribute> supportedAttributes = { Attribute_NONE };

	// Only Int32, Fp32 and Fp16 are currently supported by the TOSA Reference Model.
	std::vector<DType> supportedTypes =
	{
	DType_INT32,
	DType_FP16,
	DType_FP32
	};

	// Check the attribute, data types and bounds for inputs and outputs.
	return RunTosaLayerChecksSingleDataType(
	op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
	}
	case tosa::Op_CONST:
	{
	std::vector<Attribute> supportedAttributes = { Attribute_NONE };

	std::vector<DType> supportedTypes =
	{
	DType_FP16,
	DType_FP32,
	DType_UINT8,
	DType_INT8,
	DType_INT16,
	DType_INT32,
	DType_BOOL
	};

	// Check the attribute, data types and bounds for inputs and outputs.
	return RunTosaLayerChecksSingleDataType(
	op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
	}
	case tosa::Op_CONV2D:
	{
	std::vector<Attribute> supportedAttributes = { Attribute_ConvAttribute };

	std::vector<std::tuple<DType, DType, DType>> supportedTypesMapping =
	{
	std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP16),
	std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP32),
	std::tuple<DType, DType, DType>(DType_FP32, DType_FP32, DType_FP32),
	std::tuple<DType, DType, DType>(DType_INT8, DType_INT8, DType_INT32)
	};

	return RunTosaLayerChecksInputWeightsOutputDataType(
	op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported);
	}
	case tosa::Op_AVG_POOL2D:
	{
	std::vector<Attribute> supportedAttributes = { Attribute_PoolAttribute };

	std::vector<std::tuple<DType, DType>> supportedTypesMapping =
	{
	std::tuple<DType, DType>(DType_FP16, DType_FP16),
	std::tuple<DType, DType>(DType_FP16, DType_FP32),
	std::tuple<DType, DType>(DType_FP32, DType_FP32),
	std::tuple<DType, DType>(DType_INT8, DType_INT32),
	std::tuple<DType, DType>(DType_INT16, DType_INT32)
	};

	// Check the attribute, data types and bounds for inputs and outputs.
	return RunTosaLayerChecksInputOutputDataType(
	op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported);
	}
	case tosa::Op_MAX_POOL2D:
	{
	std::vector<Attribute> supportedAttributes = { Attribute_PoolAttribute };

	std::vector<DType> supportedTypes =
	{
	DType_FP16,
	DType_FP32,
	DType_INT8,
	DType_INT16
	};

	// Check the attribute, data types and bounds for inputs and outputs.
	return RunTosaLayerChecksSingleDataType(
	op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
	}
	case tosa::Op_PAD:
	{
	std::vector<Attribute> supportedAttributes = { Attribute_PadAttribute };

	std::vector<DType> supportedTypes =
	{
	DType_FP16,
	DType_FP32,
	DType_INT8,
	DType_INT16,
	DType_INT32,
	DType_BOOL
	};

	// Check the attribute, data types and bounds for inputs and outputs.
	return RunTosaLayerChecksSingleDataType(
	op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
	}
	default:
	SetValueChecked(reasonIfUnsupported, "Operation is currently unsupported by the TOSA Reference Backend.");
	return false;
	}
	}

	bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type,
	const std::vector<TensorInfo>& infos,
	const BaseDescriptor& descriptor,
	const Optional<LstmInputParamsInfo>& lstmParamsInfo,
	const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmInputParamsInfo,
	Optional<std::string&> reasonIfUnsupported) const
	{
	IgnoreUnused(lstmParamsInfo);
	IgnoreUnused(quantizedLstmInputParamsInfo);

	std::vector<const TensorInfo*> inputInfos;
	std::vector<const TensorInfo*> outputInfos;

	switch (type)
	{
	case LayerType::Input:
	case LayerType::Output:
	return true;
	case LayerType::Addition:
	// Setup inputs and outputs
	inputInfos.push_back(&infos[0]);
	inputInfos.push_back(&infos[1]);
	outputInfos.push_back(&infos[2]);
	break;
	case LayerType::Constant:
	outputInfos.push_back(&infos[0]);
	break;
	case LayerType::Convolution2d:
	{
	inputInfos.push_back(&infos[0]); // input
	outputInfos.push_back(&infos[1]); // output
	inputInfos.push_back(&infos[2]); // weights

	auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
	if(conv2dDesc->m_BiasEnabled)
	{
	inputInfos.push_back(&infos[3]); // bias
	}
	break;
	}
	case LayerType::Pooling2d:
	// Setup inputs and outputs
	inputInfos.push_back(&infos[0]);
	outputInfos.push_back(&infos[1]);
	break;
	default:
	break;
	}

	auto mappings = GetTosaMapping(nullptr, type, inputInfos, outputInfos, descriptor);
	if (mappings->GetName() == "")
	{
	// There currently isn't a TOSA mapping for this layer, as the default was returned.
	return false;
	}

	// Loop through block and get each tensor and operator
	for (long unsigned int i = 0; i < mappings->GetOperators().size(); ++i)
	{
	// While looping over operators check for op_UNKNOWN which is unsupported
	if (mappings->GetOperators()[i]->GetOp() == tosa::Op_UNKNOWN) { return false; }

	// Loop over operators and get GetInput/OutputTensorNames, loop over resulting names and
	// use GetTensorByName to pass pointers to tensors on to the IsTosaLayerSupported()
	std::vector<TosaSerializationTensor*> inputTensorsVect;
	for (const auto& name : mappings->GetOperators()[i]->GetInputTensorNames())
	{
	inputTensorsVect.push_back(mappings->GetTensorByName(name));
	}

	std::vector<TosaSerializationTensor*> outputTensorsVect;
	for (const auto& name : mappings->GetOperators()[i]->GetOutputTensorNames())
	{
	outputTensorsVect.push_back(mappings->GetTensorByName(name));
	}

	if (!IsTosaLayerSupported(mappings->GetOperators()[i],
	inputTensorsVect,
	outputTensorsVect,
	reasonIfUnsupported))
	{
	return false;
	}
	}
	return true;
	}

	} // namespace armnn