| // |
| // Copyright © 2019-2023 Arm Ltd and Contributors. All rights reserved. |
| // SPDX-License-Identifier: MIT |
| // |
| |
| #include "HalPolicy.hpp" |
| #include "DriverOptions.hpp" |
| |
| namespace armnn_driver |
| { |
| namespace hal_1_2 |
| { |
| |
| using namespace armnn; |
| |
| namespace |
| { |
| |
| } // anonymous namespace |
| |
| HalPolicy::DeviceType HalPolicy::GetDeviceTypeFromOptions(const DriverOptions& options) |
| { |
| // Query backends list from the options |
| auto backends = options.GetBackends(); |
| // Return first backend |
| if(backends.size()>0) |
| { |
| const auto &first_backend = backends[0]; |
| if(first_backend.IsCpuAcc()||first_backend.IsCpuRef()) |
| { |
| return V1_2::DeviceType::CPU; |
| } |
| else if(first_backend.IsGpuAcc()) |
| { |
| return V1_2::DeviceType::GPU; |
| } |
| else |
| { |
| return V1_2::DeviceType::ACCELERATOR; |
| } |
| } |
| else |
| { |
| return V1_2::DeviceType::CPU; |
| } |
| } |
| |
| bool HalPolicy::ConvertOperation(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| switch (operation.type) |
| { |
| case V1_2::OperationType::ABS: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Abs); |
| case V1_2::OperationType::ADD: |
| return ConvertElementwiseBinary(operation, model, data, BinaryOperation::Add); |
| case V1_2::OperationType::ARGMAX: |
| return ConvertArgMinMax(operation, model, data, ArgMinMaxFunction::Max); |
| case V1_2::OperationType::ARGMIN: |
| return ConvertArgMinMax(operation, model, data, ArgMinMaxFunction::Min); |
| case V1_2::OperationType::AVERAGE_POOL_2D: |
| return ConvertAveragePool2d(operation, model, data); |
| case V1_2::OperationType::BATCH_TO_SPACE_ND: |
| return ConvertBatchToSpaceNd(operation, model, data); |
| case V1_2::OperationType::CAST: |
| return ConvertCast(operation, model, data); |
| case V1_2::OperationType::CHANNEL_SHUFFLE: |
| return ConvertChannelShuffle(operation, model, data); |
| case V1_2::OperationType::CONCATENATION: |
| return ConvertConcatenation(operation, model, data); |
| case V1_2::OperationType::CONV_2D: |
| return ConvertConv2d(operation, model, data); |
| case V1_2::OperationType::DEPTH_TO_SPACE: |
| return ConvertDepthToSpace(operation, model, data); |
| case V1_2::OperationType::DEPTHWISE_CONV_2D: |
| return ConvertDepthwiseConv2d(operation, model, data); |
| case V1_2::OperationType::DEQUANTIZE: |
| return ConvertDequantize(operation, model, data); |
| case V1_2::OperationType::DIV: |
| return ConvertElementwiseBinary(operation, model, data, BinaryOperation::Div); |
| case V1_2::OperationType::EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::Equal); |
| case V1_2::OperationType::EXP: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Exp); |
| case V1_2::OperationType::EXPAND_DIMS: |
| return ConvertExpandDims(operation, model, data); |
| case V1_2::OperationType::FLOOR: |
| return ConvertFloor(operation, model, data); |
| case V1_2::OperationType::FULLY_CONNECTED: |
| return ConvertFullyConnected(operation, model, data); |
| case V1_2::OperationType::GATHER: |
| return ConvertGather(operation, model, data); |
| case V1_2::OperationType::GREATER: |
| return ConvertComparison(operation, model, data, ComparisonOperation::Greater); |
| case V1_2::OperationType::GREATER_EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::GreaterOrEqual); |
| case V1_2::OperationType::GROUPED_CONV_2D: |
| return ConvertGroupedConv2d(operation, model, data); |
| case V1_2::OperationType::INSTANCE_NORMALIZATION: |
| return ConvertInstanceNormalization(operation, model, data); |
| case V1_2::OperationType::L2_NORMALIZATION: |
| return ConvertL2Normalization(operation, model, data); |
| case V1_2::OperationType::L2_POOL_2D: |
| return ConvertL2Pool2d(operation, model, data); |
| case V1_2::OperationType::LESS: |
| return ConvertComparison(operation, model, data, ComparisonOperation::Less); |
| case V1_2::OperationType::LESS_EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::LessOrEqual); |
| case V1_2::OperationType::LOCAL_RESPONSE_NORMALIZATION: |
| return ConvertLocalResponseNormalization(operation, model, data); |
| case V1_2::OperationType::LOG: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Log); |
| case V1_2::OperationType::LOGISTIC: |
| return ConvertLogistic(operation, model, data); |
| case V1_2::OperationType::LOG_SOFTMAX: |
| return ConvertLogSoftmax(operation, model, data); |
| case V1_2::OperationType::LSTM: |
| return ConvertLstm(operation, model, data); |
| case V1_2::OperationType::MAX_POOL_2D: |
| return ConvertMaxPool2d(operation, model, data); |
| case V1_2::OperationType::MAXIMUM: |
| return ConvertElementwiseBinary(operation, model, data, BinaryOperation::Maximum); |
| case V1_2::OperationType::MEAN: |
| return ConvertMean(operation, model, data); |
| case V1_2::OperationType::MINIMUM: |
| return ConvertElementwiseBinary(operation, model, data, BinaryOperation::Minimum); |
| case V1_2::OperationType::MUL: |
| return ConvertElementwiseBinary(operation, model, data, BinaryOperation::Mul); |
| case V1_2::OperationType::NEG: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Neg); |
| case V1_2::OperationType::NOT_EQUAL: |
| return ConvertComparison(operation, model, data, ComparisonOperation::NotEqual); |
| case V1_2::OperationType::PAD: |
| return ConvertPad(operation, model, data); |
| case V1_2::OperationType::PAD_V2: |
| return ConvertPadV2(operation, model, data); |
| // There's a problem with the combination of Hal 1.2, Android Q and the POW operator. The problem does not happen |
| // with Hal 1.3. |
| // case V1_2::OperationType::POW: |
| // return ConvertElementwiseBinary(operation, model, data, BinaryOperation::Power); |
| case V1_2::OperationType::PRELU: |
| return ConvertPrelu(operation, model, data); |
| case V1_2::OperationType::QUANTIZE: |
| return ConvertQuantize(operation, model, data); |
| case V1_2::OperationType::QUANTIZED_16BIT_LSTM: |
| return ConvertQuantized16BitLstm(operation, model, data); |
| case V1_2::OperationType::REDUCE_MAX: |
| return ConvertReduce(operation, model, data, ReduceOperation::Max); |
| case V1_2::OperationType::REDUCE_MIN: |
| return ConvertReduce(operation, model, data, ReduceOperation::Min); |
| case V1_2::OperationType::REDUCE_PROD: |
| return ConvertReduce(operation, model, data, ReduceOperation::Prod); |
| case V1_2::OperationType::REDUCE_SUM: |
| return ConvertReduce(operation, model, data, ReduceOperation::Sum); |
| case V1_2::OperationType::RELU: |
| return ConvertReLu(operation, model, data); |
| case V1_2::OperationType::RELU1: |
| return ConvertReLu1(operation, model, data); |
| case V1_2::OperationType::RELU6: |
| return ConvertReLu6(operation, model, data); |
| case V1_2::OperationType::RESHAPE: |
| return ConvertReshape(operation, model, data); |
| case V1_2::OperationType::RESIZE_BILINEAR: |
| return ConvertResize(operation, model, data, ResizeMethod::Bilinear); |
| case V1_2::OperationType::RESIZE_NEAREST_NEIGHBOR: |
| return ConvertResize(operation, model, data, ResizeMethod::NearestNeighbor); |
| case V1_2::OperationType::RSQRT: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Rsqrt); |
| case V1_2::OperationType::SIN: |
| return ConvertElementwiseUnary(operation, model, data, UnaryOperation::Sin); |
| case V1_2::OperationType::SOFTMAX: |
| return ConvertSoftmax(operation, model, data); |
| case V1_2::OperationType::SPACE_TO_BATCH_ND : |
| return ConvertSpaceToBatchNd(operation, model, data); |
| case V1_2::OperationType::SPACE_TO_DEPTH: |
| return ConvertSpaceToDepth(operation, model, data); |
| case V1_2::OperationType::SPLIT: |
| return ConvertSplit(operation, model, data); |
| case V1_2::OperationType::SQRT: |
| return ConvertSqrt(operation, model, data); |
| case V1_2::OperationType::SQUEEZE: |
| return ConvertSqueeze(operation, model, data); |
| case V1_2::OperationType::STRIDED_SLICE: |
| return ConvertStridedSlice(operation, model, data); |
| case V1_2::OperationType::SUB: |
| return ConvertElementwiseBinary(operation, model, data, BinaryOperation::Sub); |
| case V1_2::OperationType::TRANSPOSE: |
| return ConvertTranspose(operation, model, data); |
| case V1_2::OperationType::TRANSPOSE_CONV_2D: |
| return ConvertTransposeConv2d(operation, model, data); |
| case V1_2::OperationType::TANH: |
| return ConvertTanH(operation, model, data); |
| case V1_2::OperationType::TILE: |
| return ConvertTile(operation, model, data); |
| case V1_2::OperationType::UNIDIRECTIONAL_SEQUENCE_LSTM: |
| return ConvertUnidirectionalSequenceLstm(operation, model, data); |
| default: |
| return Fail("%s: Operation type %s not supported in ArmnnDriver", |
| __func__, toString(operation.type).c_str()); |
| } |
| } |
| |
| bool HalPolicy::ConvertArgMinMax(const V1_2::Operation& operation, |
| const V1_2::Model& model, |
| ConversionData& data, |
| armnn::ArgMinMaxFunction argMinMaxFunction) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertArgMinMax()"); |
| return ::ConvertArgMinMax<hal_1_2::HalPolicy>(operation, model, data, argMinMaxFunction); |
| } |
| |
| bool HalPolicy::ConvertAveragePool2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertAveragePool2d()"); |
| return ConvertPooling2d<hal_1_2::HalPolicy>(operation, __func__, PoolingAlgorithm::Average, model, data); |
| } |
| |
| bool HalPolicy::ConvertBatchToSpaceNd(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertBatchToSpaceNd()"); |
| return ::ConvertBatchToSpaceNd<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertCast(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertCast()"); |
| return ::ConvertCast<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertChannelShuffle(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertChannelShuffle()"); |
| return ::ConvertChannelShuffle<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertComparison(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| ComparisonOperation comparisonOperation) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertComparison()"); |
| return ::ConvertComparison_1_2<hal_1_2::HalPolicy>(operation, model, data, comparisonOperation); |
| } |
| |
| bool HalPolicy::ConvertConcatenation(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertConcatenation()"); |
| return ::ConvertConcatenation<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertConv2d()"); |
| return ::ConvertConv2d_1_2<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertDepthToSpace(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertDepthToSpace()"); |
| return ::ConvertDepthToSpace<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertDepthwiseConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertDepthwiseConv2d()"); |
| return ::ConvertDepthwiseConv2d_1_2<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertDequantize(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertDequantize()"); |
| return ::ConvertDequantize_1_2<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertElementwiseBinary(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| BinaryOperation binaryOperation) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertElementwiseBinary()"); |
| return ::ConvertElementwiseBinary<hal_1_2::HalPolicy>(operation, model, data, binaryOperation); |
| } |
| |
| bool HalPolicy::ConvertElementwiseUnary(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| UnaryOperation unaryOperation) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertElementwiseUnary()"); |
| return ::ConvertElementwiseUnary<hal_1_2::HalPolicy>(operation, model, data, unaryOperation); |
| } |
| |
| bool HalPolicy::ConvertExpandDims(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertExpandDims()"); |
| return ::ConvertExpandDims<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertFloor(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertFloor()"); |
| return ::ConvertFloor<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertFullyConnected(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertFullyConnected()"); |
| return ::ConvertFullyConnected<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertGather (const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertGather()"); |
| return ::ConvertGather<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertGroupedConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertGroupedConv2d()"); |
| return ::ConvertGroupedConv2d<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertInstanceNormalization(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertInstanceNormalization()"); |
| return ::ConvertInstanceNormalization<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertL2Normalization(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertL2Normalization()"); |
| return ::ConvertL2Normalization<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertL2Pool2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertL2Pool2d()"); |
| return ConvertPooling2d<hal_1_2::HalPolicy>(operation, __func__, PoolingAlgorithm::L2, model, data); |
| } |
| |
| bool HalPolicy::ConvertLocalResponseNormalization(const Operation& operation, |
| const Model& model, |
| ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertLocalResponseNormalization()"); |
| return ::ConvertLocalResponseNormalization<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertLogistic(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertLogistic()"); |
| return ::ConvertLogistic<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertLogSoftmax(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertLogSoftmax()"); |
| return ::ConvertLogSoftmax<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertMaxPool2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertMaxPool2d()"); |
| return ConvertPooling2d<hal_1_2::HalPolicy>(operation, __func__, PoolingAlgorithm::Max, model, data); |
| } |
| |
| bool HalPolicy::ConvertMean(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertMean()"); |
| return ::ConvertMean<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertPad(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertPad()"); |
| return ::ConvertPad<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertPadV2(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertPadV2()"); |
| return ::ConvertPadV2<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertPrelu(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertPrelu()"); |
| return ::ConvertPrelu<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertQuantize(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertQuantize()"); |
| return ::ConvertQuantize<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertQuantized16BitLstm(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertQuantized16BitLstm()"); |
| return ::ConvertQuantized16BitLstm<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReduce(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| ReduceOperation reduceOperation) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertReduce()"); |
| return ::ConvertReduce<hal_1_2::HalPolicy>(operation, model, data, reduceOperation); |
| } |
| |
| bool HalPolicy::ConvertReLu(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertReLu()"); |
| return ::ConvertReLu<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReLu1(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertReLu1()"); |
| return ::ConvertReLu1<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReLu6(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertReLu6()"); |
| return ::ConvertReLu6<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertReshape(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertReshape()"); |
| return ::ConvertReshape<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertResize(const Operation& operation, |
| const Model& model, |
| ConversionData& data, |
| ResizeMethod resizeMethod) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertResize()"); |
| return ::ConvertResize<hal_1_2::HalPolicy>(operation, model, data, resizeMethod); |
| } |
| |
| bool HalPolicy::ConvertSpaceToBatchNd(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertSpaceToBatchNd()"); |
| return ::ConvertSpaceToBatchNd<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSpaceToDepth(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertSpaceToDepth()"); |
| return ::ConvertSpaceToDepth<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSoftmax(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertSoftmax()"); |
| return ::ConvertSoftmax<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertTanH(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertTanH()"); |
| return ::ConvertTanH<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertLstm(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertLstm()"); |
| return ::ConvertLstm<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSplit(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertSplit()"); |
| return ::ConvertSplit<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertSqrt(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertSqrt()"); |
| ActivationDescriptor desc; |
| desc.m_Function = ActivationFunction::Sqrt; |
| |
| return ::ConvertToActivation<hal_1_2::HalPolicy>(operation, __func__, desc, model, data); |
| } |
| |
| bool HalPolicy::ConvertSqueeze(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertSqueeze()"); |
| return ::ConvertSqueeze<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertStridedSlice(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertStridedSlice()"); |
| return ::ConvertStridedSlice<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertTranspose(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertTranspose()"); |
| return ::ConvertTranspose<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertTransposeConv2d(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertTransposeConv2d()"); |
| return ::ConvertTransposeConv2d<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertTile(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertTile()"); |
| return ::ConvertTile<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| bool HalPolicy::ConvertUnidirectionalSequenceLstm(const Operation& operation, const Model& model, ConversionData& data) |
| { |
| ALOGV("hal_1_2::HalPolicy::ConvertUnidirectionalSequenceLstm()"); |
| return ::ConvertUnidirectionalSequenceLstm<hal_1_2::HalPolicy>(operation, model, data); |
| } |
| |
| } // namespace hal_1_2 |
| } // namespace armnn_driver |