TosaMappings.hpp File Reference

#include <Layer.hpp>
#include <tosa_serialization_handler.h>
#include "operatorMappings/TosaCommonOperators.hpp"

Include dependency graph for TosaMappings.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
TosaSerializationBasicBlock *	GetTosaMapping (const Layer *layer, const LayerType type, const std::vector< const TensorInfo * > &inputs, const std::vector< const TensorInfo * > &outputs, const BaseDescriptor &)
TosaSerializationBasicBlock *	GetTosaMappingFromLayer (Layer *layer)

Function Documentation

GetTosaMapping()

TosaSerializationBasicBlock* GetTosaMapping	(	const Layer *	layer,
		const LayerType	type,
		const std::vector< const TensorInfo * > &	inputs,
		const std::vector< const TensorInfo * > &	outputs,
		const BaseDescriptor &
	)

Definition at line 18 of file TosaMappings.cpp.

{
    switch (type)
    {
        case LayerType::Activation:
        {
            auto activationDesc = PolymorphicDowncast<const ActivationDescriptor*>(&descriptor);
            if (activationDesc->m_Function == ActivationFunction::LeakyReLu)
            {
                return ConvertActivationToTosaOperator(layer, inputs, outputs, activationDesc);
            }
            else
            {
                return CreateEmptyTosaSerializationBasicBlock();
            }
        }
        case LayerType::Addition:
        case LayerType::Multiplication:
        case LayerType::Subtraction:
        {
            return ConvertElementwiseBinaryToTosaOperator(layer, type, inputs, outputs);
        }
        case LayerType::ElementwiseBinary:
        {
            auto binaryDesc = PolymorphicDowncast<const ElementwiseBinaryDescriptor*>(&descriptor);
            return ConvertElementwiseBinaryToTosaOperator(layer, type, inputs, outputs, binaryDesc);
        }
        case LayerType::ElementwiseUnary:
        {
            auto unaryDesc = PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor);
            return ConvertElementwiseUnaryOperator(layer, inputs, outputs, unaryDesc);
        }
        case LayerType::Concat:
        {
            auto concatDesc = PolymorphicDowncast<const OriginsDescriptor*>(&descriptor);
            return ConvertConcatToTosaOperator(layer, inputs, outputs, concatDesc);
        }
        case LayerType::Constant:
        {
            return ConvertConstantToTosaOperator(layer, outputs);
        }
        case LayerType::Convolution2d:
        {
            auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
            return ConvertConv2dToTosaOperator(layer, inputs, outputs, conv2dDesc);
        }
        case LayerType::Pooling2d:
        {
            auto poolDesc = PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor);
 
            bool avgPoolIgnoreValue =
                (poolDesc->m_PoolType == PoolingAlgorithm::Average) &&
                (poolDesc->m_PaddingMethod == PaddingMethod::IgnoreValue);
 
            if (poolDesc->m_PoolType == PoolingAlgorithm::L2)
            {
                return CreateEmptyTosaSerializationBasicBlock();
            }
            else if (avgPoolIgnoreValue)
            {
                return ConvertAvgPool2DIgnoreValueToTosaOperator(layer, inputs, outputs, poolDesc);
            }
            else
            {
                return ConvertPooling2DToTosaOperator(layer, inputs, outputs, poolDesc);
            }
        }
        case LayerType::Quantize:
        {
            return ConvertQuantizeToTosaOperator(layer, inputs, outputs);
        }
        case LayerType::Reshape:
        {
            auto reshapeDesc = PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor);
            return ConvertReshapeToTosaOperator(layer, inputs, outputs, reshapeDesc);
        }
        case LayerType::Resize:
        {
            auto resizeDesc = PolymorphicDowncast<const ResizeDescriptor*>(&descriptor);
            return ConvertResizeToTosaOperator(layer, inputs, outputs, resizeDesc);
        }
        case LayerType::Slice:
        {
            auto sliceDesc = PolymorphicDowncast<const SliceDescriptor*>(&descriptor);
            return ConvertSliceToTosaOperator(layer, inputs, outputs, sliceDesc);
        }
        case LayerType::Splitter:
        {
            auto splitDesc = PolymorphicDowncast<const SplitterDescriptor*>(&descriptor);
            return ConvertSplitToTosaOperator(layer, inputs, outputs, splitDesc);
        }
        case LayerType::TransposeConvolution2d:
        {
            auto transposeConv2dDesc = PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor);
            return ConvertTransposeConv2dToTosaOperator(layer, inputs, outputs, transposeConv2dDesc);
        }
        case LayerType::Transpose:
        {
            auto transposeDesc = PolymorphicDowncast<const TransposeDescriptor*>(&descriptor);
            return ConvertTransposeToTosaOperator(layer, inputs, outputs, transposeDesc);
        }
        default:
        {
            return CreateEmptyTosaSerializationBasicBlock();
        }
    }
}

References armnn::Activation, armnn::Addition, armnn::Average, armnn::Concat, armnn::Constant, ConvertActivationToTosaOperator(), ConvertAvgPool2DIgnoreValueToTosaOperator(), ConvertConcatToTosaOperator(), ConvertConstantToTosaOperator(), ConvertConv2dToTosaOperator(), ConvertElementwiseBinaryToTosaOperator(), ConvertElementwiseUnaryOperator(), ConvertPooling2DToTosaOperator(), ConvertQuantizeToTosaOperator(), ConvertReshapeToTosaOperator(), ConvertResizeToTosaOperator(), ConvertSliceToTosaOperator(), ConvertSplitToTosaOperator(), ConvertTransposeConv2dToTosaOperator(), ConvertTransposeToTosaOperator(), armnn::Convolution2d, CreateEmptyTosaSerializationBasicBlock(), armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::IgnoreValue, armnn::L2, armnn::LeakyReLu, armnn::Multiplication, armnn::Pooling2d, armnn::Quantize, armnn::Reshape, armnn::Resize, armnn::Slice, armnn::Splitter, armnn::Subtraction, armnn::Transpose, and armnn::TransposeConvolution2d.

Referenced by GetTosaMappingFromLayer(), and TosaRefLayerSupport::IsLayerSupported().

GetTosaMappingFromLayer()

TosaSerializationBasicBlock* GetTosaMappingFromLayer

(

Layer *

layer

)

Definition at line 130 of file TosaMappings.cpp.

{
    std::vector<const TensorInfo*> inputs;
    for (auto inputSlot : layer->GetInputSlots())
    {
        inputs.push_back(&inputSlot.GetTensorInfo());
    }
 
    std::vector<const TensorInfo*> outputs;
    for (auto& outputSlot : layer->GetOutputSlots())
    {
        outputs.push_back(&outputSlot.GetTensorInfo());
    }
 
    TosaSerializationBasicBlock* basicBlock = GetTosaMapping(layer,
                                                             layer->GetType(),
                                                             inputs,
                                                             outputs,
                                                             layer->GetParameters());
    return basicBlock;
}

References Layer::GetInputSlots(), Layer::GetOutputSlots(), Layer::GetParameters(), GetTosaMapping(), and Layer::GetType().

Referenced by TosaRefBackend::OptimizeSubgraphView().