From 42477c1d3e7ddf74863e84ab79dbe6f42e4a0ba3 Mon Sep 17 00:00:00 2001 From: Kevin May Date: Thu, 26 Mar 2020 13:34:14 +0000 Subject: IVGCVSW-4447 Add Hal 1_3 Support * Add new 1.3 files HalPolicy, ArmnnDriver, ArmnnDriverImpl * Add new .rc file for 1.3 service * Add ArmnnPreparedModel_1_3 and implement new functions * Update Android.mk with 1.3 driver and service * Refactor ifdef to include ARMNN_ANDROID_NN_V1_3 * Create Utils getMainModel for new 1.3 Model Main Subgraph * Use android Utils to convertToV1_X in ArmnnPrepapredModel_1_3 * Refactor HAL 1.2 convert functions into ConversionUtils_1_2.hpp * Replace ArmnnBurstExecutorWithCache with call to ExecutionBurstServer Signed-off-by: Kevin May Change-Id: I514069e9e1b16bcd1c4abfb5d563d25ac22d02e3 --- 1.3/HalPolicy.cpp | 451 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 451 insertions(+) create mode 100644 1.3/HalPolicy.cpp (limited to '1.3/HalPolicy.cpp') diff --git a/1.3/HalPolicy.cpp b/1.3/HalPolicy.cpp new file mode 100644 index 00000000..0de7573a --- /dev/null +++ b/1.3/HalPolicy.cpp @@ -0,0 +1,451 @@ +// +// 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::EQUAL: + return ConvertComparison(operation, model, data, ComparisonOperation::Equal); + case V1_3::OperationType::EXPAND_DIMS: + return ConvertExpandDims(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::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::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::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_16BIT_LSTM: + return ConvertQuantizedLstm(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(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(operation, model, data, argMinMaxFunction); +} + +bool HalPolicy::ConvertAveragePool2d(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertAveragePool2d()"); + return ConvertPooling2d(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(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(operation, model, data, comparisonOperation); +} + + +bool HalPolicy::ConvertConcatenation(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertConcatenation()"); + return ::ConvertConcatenation(operation, model, data); +} + +bool HalPolicy::ConvertConv2d(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertConv2d()"); + return ::ConvertConv2d_1_2(operation, model, data); +} + +bool HalPolicy::ConvertDepthToSpace(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertDepthToSpace()"); + return ::ConvertDepthToSpace(operation, model, data); +} + +bool HalPolicy::ConvertDepthwiseConv2d(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertDepthwiseConv2d()"); + return ::ConvertDepthwiseConv2d_1_2(operation, model, data); +} + +bool HalPolicy::ConvertDequantize(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertDequantize()"); + return ::ConvertDequantize_1_2(operation, model, data); +} + +bool HalPolicy::ConvertDiv(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertDiv()"); + return ::ConvertDiv(operation, model, data); +} + +bool HalPolicy::ConvertElementwiseUnary(const Operation& operation, + const Model& model, + ConversionData& data, + UnaryOperation unaryOperation) +{ + ALOGV("hal_1_3::HalPolicy::ConvertElementwiseUnary()"); + return ::ConvertElementwiseUnary(operation, model, data, unaryOperation); +} + +bool HalPolicy::ConvertExpandDims(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertExpandDims()"); + return ::ConvertExpandDims(operation, model, data); +} + +bool HalPolicy::ConvertFloor(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertFloor()"); + return ::ConvertFloor(operation, model, data); +} + +bool HalPolicy::ConvertFullyConnected(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertFullyConnected()"); + return ::ConvertFullyConnected(operation, model, data); +} + +bool HalPolicy::ConvertGroupedConv2d(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertGroupedConv2d()"); + return ::ConvertGroupedConv2d(operation, model, data); +} + +bool HalPolicy::ConvertInstanceNormalization(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertInstanceNormalization()"); + return ::ConvertInstanceNormalization(operation, model, data); +} + +bool HalPolicy::ConvertL2Normalization(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertL2Normalization()"); + return ::ConvertL2Normalization(operation, model, data); +} + +bool HalPolicy::ConvertL2Pool2d(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertL2Pool2d()"); + return ConvertPooling2d(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(operation, model, data); +} + +bool HalPolicy::ConvertLogistic(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertLogistic()"); + return ::ConvertLogistic(operation, model, data); +} + +bool HalPolicy::ConvertLogSoftmax(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertLogSoftmax()"); + return ::ConvertLogSoftmax(operation, model, data); +} + +bool HalPolicy::ConvertLstm(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertLstm()"); + return ::ConvertLstm(operation, model, data); +} + +bool HalPolicy::ConvertMaxPool2d(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertMaxPool2d()"); + return ConvertPooling2d(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(operation, model, data); +} + +bool HalPolicy::ConvertMean(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertMean()"); + return ::ConvertMean(operation, model, data); +} + +bool HalPolicy::ConvertMinimum(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertMinimum()"); + return ::ConvertMinimum(operation, model, data); +} + +bool HalPolicy::ConvertMul(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertMul()"); + return ::ConvertMul(operation, model, data); +} + +bool HalPolicy::ConvertPad(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertPad()"); + return ::ConvertPad(operation, model, data); +} + +bool HalPolicy::ConvertPadV2(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertPadV2()"); + return ::ConvertPadV2(operation, model, data); +} + +bool HalPolicy::ConvertPrelu(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertPrelu()"); + return ::ConvertPrelu(operation, model, data); +} + +bool HalPolicy::ConvertQuantize(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertQuantize()"); + return ::ConvertQuantize(operation, model, data); +} + +bool HalPolicy::ConvertQuantizedLstm(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertQuantizedLstm()"); + return ::ConvertQuantizedLstm(operation, model, data); +} + +bool HalPolicy::ConvertReLu(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertReLu()"); + return ::ConvertReLu(operation, model, data); +} + +bool HalPolicy::ConvertReLu1(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertReLu1()"); + return ::ConvertReLu1(operation, model, data); +} + +bool HalPolicy::ConvertReLu6(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertReLu6()"); + return ::ConvertReLu6(operation, model, data); +} + +bool HalPolicy::ConvertReshape(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertReshape()"); + return ::ConvertReshape(operation, model, data); +} + +bool HalPolicy::ConvertResize(const Operation& operation, + const Model& model, + ConversionData& data, + ResizeMethod resizeMethod) +{ + ALOGV("hal_1_3::HalPolicy::ConvertResize()"); + return ::ConvertResize(operation, model, data, resizeMethod); +} + +bool HalPolicy::ConvertSpaceToBatchNd(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertSpaceToBatchNd()"); + return ::ConvertSpaceToBatchNd(operation, model, data); +} + +bool HalPolicy::ConvertSpaceToDepth(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertSpaceToDepth()"); + return ::ConvertSpaceToDepth(operation, model, data); +} + +bool HalPolicy::ConvertSoftmax(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertSoftmax()"); + return ::ConvertSoftmax(operation, model, data); +} + +bool HalPolicy::ConvertSub(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertSub()"); + return ::ConvertSub(operation, model, data); +} + +bool HalPolicy::ConvertTanH(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertTanH()"); + return ::ConvertTanH(operation, model, data); +} + +bool HalPolicy::ConvertTransposeConv2d(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertTransposeConv2d()"); + return ::ConvertTransposeConv2d(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(operation, __func__, desc, model, data); +} + +bool HalPolicy::ConvertSqueeze(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertSqueeze()"); + return ::ConvertSqueeze(operation, model, data); +} + +bool HalPolicy::ConvertStridedSlice(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertStridedSlice()"); + return ::ConvertStridedSlice(operation, model, data); +} + +bool HalPolicy::ConvertTranspose(const Operation& operation, const Model& model, ConversionData& data) +{ + ALOGV("hal_1_3::HalPolicy::ConvertTranspose()"); + return ::ConvertTranspose(operation, model, data); +} + +} // namespace hal_1_3 +} // namespace armnn_driver -- cgit v1.2.1