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 <kevin.may@arm.com>
Change-Id: I514069e9e1b16bcd1c4abfb5d563d25ac22d02e3

1 files changed, 451 insertions, 0 deletions

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<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::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::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::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::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::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::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