| // |
| // Copyright © 2020 Arm Ltd. All rights reserved. |
| // SPDX-License-Identifier: MIT |
| // |
| |
| #include "HalPolicy.hpp" |
| |
| namespace armnn_driver |
| { |
| namespace hal_1_3 |
| { |
| |
| using namespace armnn; |
| |
| namespace |
| { |
| |
| } // anonymouse namespace |
| |
| bool HalPolicy::ConvertOperation(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| switch (operation.type) |
| { |
| case V1_3::OperationType::ABS: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Abs); |
| case V1_3::OperationType::ADD: |
| return ConvertAdd(operation, model, data); |
| case V1_3::OperationType::ARGMAX: |
| return ConvertArgMinMax(operation, model, data, ArgMinMaxFunction::Max); |
| case V1_3::OperationType::ARGMIN: |
| return ConvertArgMinMax(operation, model, data, ArgMinMaxFunction::Min); |
| case V1_3::OperationType::AVERAGE_POOL_2D: |
| return ConvertAveragePool2d(operation, model, data); |
| case V1_3::OperationType::BATCH_TO_SPACE_ND: |
| return ConvertBatchToSpaceNd(operation, model, data); |
| case V1_3::OperationType::CONCATENATION: |
| return ConvertConcatenation(operation, model, data); |
| case V1_3::OperationType::CONV_2D: |
| return ConvertConv2d(operation, model, data); |
| case V1_3::OperationType::DEPTH_TO_SPACE: |
| return ConvertDepthToSpace(operation, model, data); |
| case V1_3::OperationType::DEPTHWISE_CONV_2D: |
| return ConvertDepthwiseConv2d(operation, model, data); |
| case V1_3::OperationType::DEQUANTIZE: |
| return ConvertDequantize(operation, model, data); |
| case V1_3::OperationType::DIV: |
| return ConvertDiv(operation, model, data); |
| case V1_3::OperationType::ELU: |
| return ConvertElu(operation, model, data); |
| case V1_3::OperationType::EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::Equal); |
| case V1_3::OperationType::EXP: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Exp); |
| case V1_3::OperationType::EXPAND_DIMS: |
| return ConvertExpandDims(operation, model, data); |
| case V1_3::OperationType::FILL: |
| return ConvertFill(operation, model, data); |
| case V1_3::OperationType::FLOOR: |
| return ConvertFloor(operation, model, data); |
| case V1_3::OperationType::FULLY_CONNECTED: |
| return ConvertFullyConnected(operation, model, data); |
| case V1_3::OperationType::GATHER: |
| return ConvertGather(operation, model, data); |
| case V1_3::OperationType::GREATER: |
| return ConvertComparison(operation, model, data, ComparisonOperation::Greater); |
| case V1_3::OperationType::GREATER_EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::GreaterOrEqual); |
| case V1_3::OperationType::GROUPED_CONV_2D: |
| return ConvertGroupedConv2d(operation, model, data); |
| case V1_3::OperationType::HARD_SWISH: |
| return ConvertHardSwish(operation, model, data); |
| case V1_3::OperationType::INSTANCE_NORMALIZATION: |
| return ConvertInstanceNormalization(operation, model, data); |
| case V1_3::OperationType::L2_NORMALIZATION: |
| return ConvertL2Normalization(operation, model, data); |
| case V1_3::OperationType::L2_POOL_2D: |
| return ConvertL2Pool2d(operation, model, data); |
| case V1_3::OperationType::LESS: |
| return ConvertComparison(operation, model, data, ComparisonOperation::Less); |
| case V1_3::OperationType::LESS_EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::LessOrEqual); |
| case V1_3::OperationType::LOCAL_RESPONSE_NORMALIZATION: |
| return ConvertLocalResponseNormalization(operation, model, data); |
| case V1_3::OperationType::LOGICAL_AND: |
| return ConvertLogicalBinary(operation, model, data, LogicalBinaryOperation::LogicalAnd); |
| case V1_3::OperationType::LOGICAL_NOT: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::LogicalNot); |
| case V1_3::OperationType::LOGICAL_OR: |
| return ConvertLogicalBinary(operation, model, data, LogicalBinaryOperation::LogicalOr); |
| case V1_3::OperationType::LOGISTIC: |
| return ConvertLogistic(operation, model, data); |
| case V1_3::OperationType::LOG_SOFTMAX: |
| return ConvertLogSoftmax(operation, model, data); |
| case V1_3::OperationType::LSTM: |
| return ConvertLstm(operation, model, data); |
| case V1_3::OperationType::MAX_POOL_2D: |
| return ConvertMaxPool2d(operation, model, data); |
| case V1_3::OperationType::MAXIMUM: |
| return ConvertMaximum(operation, model, data); |
| case V1_3::OperationType::MEAN: |
| return ConvertMean(operation, model, data); |
| case V1_3::OperationType::MINIMUM: |
| return ConvertMinimum(operation, model, data); |
| case V1_3::OperationType::MUL: |
| return ConvertMul(operation, model, data); |
| case V1_3::OperationType::NEG: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Neg); |
| case V1_3::OperationType::NOT_EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::NotEqual); |
| case V1_3::OperationType::PAD: |
| return ConvertPad(operation, model, data); |
| case V1_3::OperationType::PAD_V2: |
| return ConvertPadV2(operation, model, data); |
| case V1_3::OperationType::PRELU: |
| return ConvertPrelu(operation, model, data); |
| case V1_3::OperationType::QUANTIZE: |
| return ConvertQuantize(operation, model, data); |
| case V1_3::OperationType::QUANTIZED_LSTM: |
| return ConvertQuantizedLstm(operation, model, data); |
| case V1_3::OperationType::QUANTIZED_16BIT_LSTM: |
| return ConvertQuantized16BitLstm(operation, model, data); |
| case V1_3::OperationType::RANK: |
| return ConvertRank(operation, model, data); |
| case V1_3::OperationType::RELU: |
| return ConvertReLu(operation, model, data); |
| case V1_3::OperationType::RELU1: |
| return ConvertReLu1(operation, model, data); |
| case V1_3::OperationType::RELU6: |
| return ConvertReLu6(operation, model, data); |
| case V1_3::OperationType::RESHAPE: |
| return ConvertReshape(operation, model, data); |
| case V1_3::OperationType::RESIZE_BILINEAR: |
| return ConvertResize(operation, model, data, ResizeMethod::Bilinear); |
| case V1_3::OperationType::RESIZE_NEAREST_NEIGHBOR: |
| return ConvertResize(operation, model, data, ResizeMethod::NearestNeighbor); |
| case V1_3::OperationType::RSQRT: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Rsqrt); |
| case V1_3::OperationType::SQRT: |
| return ConvertSqrt(operation, model, data); |
| case V1_3::OperationType::SQUEEZE: |
| return ConvertSqueeze(operation, model, data); |
| case V1_3::OperationType::STRIDED_SLICE: |
| return ConvertStridedSlice(operation, model, data); |
| case V1_3::OperationType::TRANSPOSE: |
| return ConvertTranspose(operation, model, data); |
| case V1_3::OperationType::TRANSPOSE_CONV_2D: |
| return ConvertTransposeConv2d(operation, model, data); |
| case V1_3::OperationType::SOFTMAX: |
| return ConvertSoftmax(operation, model, data); |
| case V1_3::OperationType::SPACE_TO_BATCH_ND : |
| return ConvertSpaceToBatchNd(operation, model, data); |
| case V1_3::OperationType::SPACE_TO_DEPTH: |
| return ConvertSpaceToDepth(operation, model, data); |
| case V1_3::OperationType::SUB: |
| return ConvertSub(operation, model, data); |
| case V1_3::OperationType::TANH: |
| return ConvertTanH(operation, model, data); |
| default: |
| return Fail("%s: Operation type %s not supported in ArmnnDriver", |
| __func__, toString(operation.type).c_str()); |
| } |
| } |
| |
| bool HalPolicy::ConvertAdd(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertAdd()"); |
| return ::ConvertAdd<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertArgMinMax(const V1_3::Operation& operation, |
| const V1_3::Model& model, |
| ConversionData& data, |
| armnn::ArgMinMaxFunction argMinMaxFunction) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertArgMinMax()"); |
| return ::ConvertArgMinMax<hal_1_3::HalPolicy>(operation, model, data, argMinMaxFunction); |
| } |
| |
| bool HalPolicy::ConvertAveragePool2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertAveragePool2d()"); |
| return ConvertPooling2d<hal_1_3::HalPolicy>(operation, __func__, PoolingAlgorithm::Average, model, data); |
| } |
| |
| bool HalPolicy::ConvertBatchToSpaceNd(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertBatchToSpaceNd()"); |
| return ::ConvertBatchToSpaceNd<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertComparison(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| ComparisonOperation comparisonOperation) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertComparison()"); |
| return ::ConvertComparison_1_2<hal_1_3::HalPolicy>(operation, model, data, comparisonOperation); |
| } |
| |
| |
| bool HalPolicy::ConvertConcatenation(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertConcatenation()"); |
| return ::ConvertConcatenation<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertConv2d()"); |
| return ::ConvertConv2d_1_2<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertDepthToSpace(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertDepthToSpace()"); |
| return ::ConvertDepthToSpace<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertDepthwiseConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertDepthwiseConv2d()"); |
| return ::ConvertDepthwiseConv2d_1_2<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertDequantize(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertDequantize()"); |
| return ::ConvertDequantize_1_2<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertDiv(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertDiv()"); |
| return ::ConvertDiv<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertElementwiseUnary(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| UnaryOperation unaryOperation) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertElementwiseUnary()"); |
| return ::ConvertElementwiseUnary<hal_1_3::HalPolicy>(operation, model, data, unaryOperation); |
| } |
| |
| bool HalPolicy::ConvertElu(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertElu()"); |
| return ::ConvertElu<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertExpandDims(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertExpandDims()"); |
| return ::ConvertExpandDims<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertFill(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertFill()"); |
| return ::ConvertFill<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertFloor(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertFloor()"); |
| return ::ConvertFloor<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertFullyConnected(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertFullyConnected()"); |
| return ::ConvertFullyConnected<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertGather(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertGather()"); |
| return ::ConvertGather<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertGroupedConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertGroupedConv2d()"); |
| return ::ConvertGroupedConv2d<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertHardSwish(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertHardSwish()"); |
| ActivationDescriptor desc; |
| desc.m_Function = ActivationFunction::HardSwish; |
| |
| return ::ConvertToActivation<hal_1_3::HalPolicy>(operation, __func__, desc, model, data); |
| } |
| |
| bool HalPolicy::ConvertInstanceNormalization(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertInstanceNormalization()"); |
| return ::ConvertInstanceNormalization<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertL2Normalization(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertL2Normalization()"); |
| return ::ConvertL2Normalization<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertL2Pool2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertL2Pool2d()"); |
| return ConvertPooling2d<hal_1_3::HalPolicy>(operation, __func__, PoolingAlgorithm::L2, model, data); |
| } |
| |
| bool HalPolicy::ConvertLocalResponseNormalization(const Operation& operation, |
| const Model& model, |
| ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertLocalResponseNormalization()"); |
| return ::ConvertLocalResponseNormalization<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertLogicalBinary(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| armnn::LogicalBinaryOperation logicalOperation) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertLogicalBinary()"); |
| return ::ConvertLogicalBinary<hal_1_3::HalPolicy>(operation, model, data, logicalOperation); |
| } |
| |
| bool HalPolicy::ConvertLogistic(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertLogistic()"); |
| return ::ConvertLogistic<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertLogSoftmax(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertLogSoftmax()"); |
| return ::ConvertLogSoftmax<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertLstm(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertLstm()"); |
| return ::ConvertLstm<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertMaxPool2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertMaxPool2d()"); |
| return ConvertPooling2d<hal_1_3::HalPolicy>(operation, __func__, PoolingAlgorithm::Max, model, data); |
| } |
| |
| bool HalPolicy::ConvertMaximum(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertConvertMaximumMaximum()"); |
| return ::ConvertMaximum<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertMean(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertMean()"); |
| return ::ConvertMean<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertMinimum(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertMinimum()"); |
| return ::ConvertMinimum<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertMul(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertMul()"); |
| return ::ConvertMul<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertPad(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertPad()"); |
| return ::ConvertPad<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertPadV2(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertPadV2()"); |
| return ::ConvertPadV2<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertPrelu(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertPrelu()"); |
| return ::ConvertPrelu<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertQuantize(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertQuantize()"); |
| return ::ConvertQuantize<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertQuantizedLstm(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertQuantizedLstm()"); |
| return ::ConvertQuantizedLstm<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertQuantized16BitLstm(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertQuantized16BitLstm()"); |
| return ::ConvertQuantized16BitLstm<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertRank(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertRank()"); |
| return ::ConvertRank<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReLu(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertReLu()"); |
| return ::ConvertReLu<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReLu1(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertReLu1()"); |
| return ::ConvertReLu1<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReLu6(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertReLu6()"); |
| return ::ConvertReLu6<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReshape(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertReshape()"); |
| return ::ConvertReshape<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertResize(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| ResizeMethod resizeMethod) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertResize()"); |
| return ::ConvertResize<hal_1_3::HalPolicy>(operation, model, data, resizeMethod); |
| } |
| |
| bool HalPolicy::ConvertSpaceToBatchNd(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertSpaceToBatchNd()"); |
| return ::ConvertSpaceToBatchNd<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSpaceToDepth(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertSpaceToDepth()"); |
| return ::ConvertSpaceToDepth<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSoftmax(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertSoftmax()"); |
| return ::ConvertSoftmax<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSub(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertSub()"); |
| return ::ConvertSub<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertTanH(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertTanH()"); |
| return ::ConvertTanH<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertTransposeConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertTransposeConv2d()"); |
| return ::ConvertTransposeConv2d<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSqrt(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertSqrt()"); |
| ActivationDescriptor desc; |
| desc.m_Function = ActivationFunction::Sqrt; |
| |
| return ::ConvertToActivation<hal_1_3::HalPolicy>(operation, __func__, desc, model, data); |
| } |
| |
| bool HalPolicy::ConvertSqueeze(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertSqueeze()"); |
| return ::ConvertSqueeze<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertStridedSlice(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertStridedSlice()"); |
| return ::ConvertStridedSlice<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertTranspose(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_3::HalPolicy::ConvertTranspose()"); |
| return ::ConvertTranspose<hal_1_3::HalPolicy>(operation, model, data); |
| } |
| |
| } // namespace hal_1_3 |
| } // namespace armnn_driver |
