EthosnRefLayerSupport.cpp

Go to the documentation of this file.

//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include "EthosnRefLayerSupport.hpp"
#include "EthosnRefBackendId.hpp"

#include <armnn/Types.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/BackendRegistry.hpp>

#include <armnnUtils/DataLayoutIndexed.hpp>

#include <InternalTypes.hpp>
#include <LayerSupportCommon.hpp>

#include <backendsCommon/LayerSupportRules.hpp>

#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/NumericCast.hpp>

#include <vector>
#include <algorithm>
#include <array>

namespace armnn
{

bool EthosnRefLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
                                               const TensorInfo& output,
                                               const Convolution2dDescriptor& descriptor,
                                               const TensorInfo& weights,
                                               const Optional<TensorInfo>& biases,
                                               Optional<std::string&> reasonIfUnsupported) const
{
    bool supported = true;

    // Define supported types.
    std::array<DataType,3> supportedTypes =
    {
        DataType::QAsymmU8,
        DataType::QSymmS8,
        DataType::QSymmS16
    };

    supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference Convolution2d: input is not a supported type.");

    supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference Convolution2d: output is not a supported type.");

    supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
                                  "EthosnReference Convolution2d: input and output types mismatched.");

    supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference Convolution2d: weights is not a supported type.");

    supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
                                  "EthosnReference Convolution2d: input and weights types mismatched.");

    if (biases.has_value())
    {
        std::array<DataType,1> biasesSupportedTypes =
        {
            DataType::Signed32
        };

        supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
                                      "EthosnReference Convolution2d: biases is not a supported type.");
    }
    IgnoreUnused(descriptor);

    return supported;
}

bool EthosnRefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
                                                      const TensorInfo& output,
                                                      const DepthwiseConvolution2dDescriptor& descriptor,
                                                      const TensorInfo& weights,
                                                      const Optional<TensorInfo>& biases,
                                                      Optional<std::string&> reasonIfUnsupported) const
{
    bool supported = true;


    // Define supported types.
    std::array<DataType,3> supportedTypes =
    {
        DataType::QAsymmU8,
        DataType::QSymmS8,
        DataType::QSymmS16
    };

    supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference DepthwiseConvolution2d: input is not a supported type.");

    supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference DepthwiseConvolution2d: output is not a supported type.");

    supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
                                  "EthosnReference DepthwiseConvolution2d: input and output types mismatched.");

    supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference DepthwiseConvolution2d: weights is not a supported type.");

    supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
                                  "EthosnReference DepthwiseConvolution2d: input and weights types mismatched.");

    if (biases.has_value())
    {
        std::array<DataType,1> biasesSupportedTypes =
        {
            DataType::Signed32
        };

        supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
                                      "EthosnReference DepthwiseConvolution2d: biases is not a supported type.");
    }
    IgnoreUnused(descriptor);

    return supported;
}



bool EthosnRefLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input,
                                                           const TensorInfo& output,
                                                           const TransposeConvolution2dDescriptor& descriptor,
                                                           const TensorInfo& weights,
                                                           const Optional<TensorInfo>& biases,
                                                           Optional<std::string&> reasonIfUnsupported) const
{
    bool supported = true;


    // Define supported types.
    std::array<DataType,3> supportedTypes =
    {
        DataType::QAsymmU8,
        DataType::QSymmS8,
        DataType::QSymmS16
    };

    supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference TransposeConvolution2d: input is not a supported type.");

    supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference TransposeConvolution2d: output is not a supported type.");

    supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
                                  "EthosnReference TransposeConvolution2d: input and output types mismatched.");

    supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference TransposeConvolution2d: weights is not a supported type.");

    supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
                                  "EthosnReference TransposeConvolution2d: input and weights types mismatched.");

    if (biases.has_value())
    {
        std::array<DataType,1> biasesSupportedTypes =
        {
            DataType::Signed32
        };

        supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
                                      "EthosnReference TransposeConvolution2d: biases is not a supported type.");
    }
    IgnoreUnused(descriptor);

    return supported;
}

bool EthosnRefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
                                           const TensorInfo& output,
                                           const Pooling2dDescriptor& descriptor,
                                           Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(descriptor);
    bool supported = true;

    // Define supported output and inputs types.
    std::array<DataType,3> supportedTypes =
    {
        DataType::QAsymmS8,
        DataType::QAsymmU8,
        DataType::QSymmS16
    };

    supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference Poolind2d: input is not a supported type.");

    supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
                                  "EthosnReference Poolind2d: output is not a supported type.");

    supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
                                  "EthosnReference Poolind2d: input and output types are mismatched.");

    supported = (descriptor.m_PoolType == armnn::PoolingAlgorithm::Average);
    if ( descriptor.m_PoolType != armnn::PoolingAlgorithm::Average)
    {
        reasonIfUnsupported.value() += "EthosnReference poolind2d: pooling algorithm is not supported.";
    }

    return supported;
}

} // namespace armnn