Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6b6dfcd4 authored by Lev Proleev's avatar Lev Proleev
Browse files

Add utils for AIDL types conversions 

Add conversions between canonical types and NNAPI AIDL interface types
that are needed for AIDL sample driver implementation.

Bug: 172922059
Test: VtsNeuralnetworksTargetTest
Change-Id: I02803302e02457e52c752114b47b94239eff20e9
Merged-In: I02803302e02457e52c752114b47b94239eff20e9
(cherry picked from commit 532136b9)
parent bfd12c66

neuralnetworks/aidl/Android.bp

+8 −0
Original line number Diff line number Diff line
@@ -15,5 +15,13 @@ aidl_interface { 
        cpp: {

            enabled: false,

        },

        ndk: {

            apex_available: [

                "//apex_available:platform",

                "com.android.neuralnetworks",

                "test_com.android.neuralnetworks",

            ],

            min_sdk_version: "30",

        },

    },

}

neuralnetworks/aidl/utils/Android.bp

0 → 100644
+32 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2021 The Android Open Source Project

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//



cc_library_static {

    name: "neuralnetworks_utils_hal_aidl",

    defaults: ["neuralnetworks_utils_defaults"],

    srcs: ["src/*"],

    local_include_dirs: ["include/nnapi/hal/aidl/"],

    export_include_dirs: ["include"],

    static_libs: [

        "neuralnetworks_types",

        "neuralnetworks_utils_hal_common",

    ],

    shared_libs: [

        "libhidlbase",

        "android.hardware.neuralnetworks-V1-ndk_platform",

        "libbinder_ndk",

    ],

}

neuralnetworks/aidl/utils/OWNERS

0 → 100644
+11 −0
Original line number Diff line number Diff line 
# Neuralnetworks team

butlermichael@google.com

dgross@google.com

galarragas@google.com

jeanluc@google.com

levp@google.com

miaowang@google.com

pszczepaniak@google.com

slavash@google.com

vddang@google.com

xusongw@google.com

neuralnetworks/aidl/utils/include/nnapi/hal/aidl/Conversions.h

0 → 100644
+134 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_AIDL_CONVERSIONS_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_AIDL_CONVERSIONS_H



#include <aidl/android/hardware/neuralnetworks/BufferDesc.h>

#include <aidl/android/hardware/neuralnetworks/BufferRole.h>

#include <aidl/android/hardware/neuralnetworks/Capabilities.h>

#include <aidl/android/hardware/neuralnetworks/DataLocation.h>

#include <aidl/android/hardware/neuralnetworks/DeviceType.h>

#include <aidl/android/hardware/neuralnetworks/ErrorStatus.h>

#include <aidl/android/hardware/neuralnetworks/ExecutionPreference.h>

#include <aidl/android/hardware/neuralnetworks/Extension.h>

#include <aidl/android/hardware/neuralnetworks/ExtensionNameAndPrefix.h>

#include <aidl/android/hardware/neuralnetworks/ExtensionOperandTypeInformation.h>

#include <aidl/android/hardware/neuralnetworks/Memory.h>

#include <aidl/android/hardware/neuralnetworks/Model.h>

#include <aidl/android/hardware/neuralnetworks/Operand.h>

#include <aidl/android/hardware/neuralnetworks/OperandExtraParams.h>

#include <aidl/android/hardware/neuralnetworks/OperandLifeTime.h>

#include <aidl/android/hardware/neuralnetworks/OperandPerformance.h>

#include <aidl/android/hardware/neuralnetworks/OperandType.h>

#include <aidl/android/hardware/neuralnetworks/Operation.h>

#include <aidl/android/hardware/neuralnetworks/OperationType.h>

#include <aidl/android/hardware/neuralnetworks/OutputShape.h>

#include <aidl/android/hardware/neuralnetworks/PerformanceInfo.h>

#include <aidl/android/hardware/neuralnetworks/Priority.h>

#include <aidl/android/hardware/neuralnetworks/Request.h>

#include <aidl/android/hardware/neuralnetworks/RequestArgument.h>

#include <aidl/android/hardware/neuralnetworks/RequestMemoryPool.h>

#include <aidl/android/hardware/neuralnetworks/Subgraph.h>

#include <aidl/android/hardware/neuralnetworks/SymmPerChannelQuantParams.h>

#include <aidl/android/hardware/neuralnetworks/Timing.h>



#include <nnapi/Result.h>

#include <nnapi/Types.h>

#include <nnapi/hal/CommonUtils.h>



#include <vector>



namespace android::nn {



GeneralResult<OperandType> unvalidatedConvert(const aidl_hal::OperandType& operandType);

GeneralResult<OperationType> unvalidatedConvert(const aidl_hal::OperationType& operationType);

GeneralResult<DeviceType> unvalidatedConvert(const aidl_hal::DeviceType& deviceType);

GeneralResult<Priority> unvalidatedConvert(const aidl_hal::Priority& priority);

GeneralResult<Capabilities> unvalidatedConvert(const aidl_hal::Capabilities& capabilities);

GeneralResult<Capabilities::OperandPerformance> unvalidatedConvert(

        const aidl_hal::OperandPerformance& operandPerformance);

GeneralResult<Capabilities::PerformanceInfo> unvalidatedConvert(

        const aidl_hal::PerformanceInfo& performanceInfo);

GeneralResult<DataLocation> unvalidatedConvert(const aidl_hal::DataLocation& location);

GeneralResult<Operand> unvalidatedConvert(const aidl_hal::Operand& operand);

GeneralResult<Operand::ExtraParams> unvalidatedConvert(

        const std::optional<aidl_hal::OperandExtraParams>& optionalExtraParams);

GeneralResult<Operand::LifeTime> unvalidatedConvert(

        const aidl_hal::OperandLifeTime& operandLifeTime);

GeneralResult<Operand::SymmPerChannelQuantParams> unvalidatedConvert(

        const aidl_hal::SymmPerChannelQuantParams& symmPerChannelQuantParams);

GeneralResult<Operation> unvalidatedConvert(const aidl_hal::Operation& operation);

GeneralResult<Model> unvalidatedConvert(const aidl_hal::Model& model);

GeneralResult<Model::ExtensionNameAndPrefix> unvalidatedConvert(

        const aidl_hal::ExtensionNameAndPrefix& extensionNameAndPrefix);

GeneralResult<Model::OperandValues> unvalidatedConvert(const std::vector<uint8_t>& operandValues);

GeneralResult<Model::Subgraph> unvalidatedConvert(const aidl_hal::Subgraph& subgraph);

GeneralResult<OutputShape> unvalidatedConvert(const aidl_hal::OutputShape& outputShape);

GeneralResult<MeasureTiming> unvalidatedConvert(bool measureTiming);

GeneralResult<Memory> unvalidatedConvert(const aidl_hal::Memory& memory);

GeneralResult<Timing> unvalidatedConvert(const aidl_hal::Timing& timing);

GeneralResult<BufferDesc> unvalidatedConvert(const aidl_hal::BufferDesc& bufferDesc);

GeneralResult<BufferRole> unvalidatedConvert(const aidl_hal::BufferRole& bufferRole);

GeneralResult<Request> unvalidatedConvert(const aidl_hal::Request& request);

GeneralResult<Request::Argument> unvalidatedConvert(

        const aidl_hal::RequestArgument& requestArgument);

GeneralResult<Request::MemoryPool> unvalidatedConvert(

        const aidl_hal::RequestMemoryPool& memoryPool);

GeneralResult<ErrorStatus> unvalidatedConvert(const aidl_hal::ErrorStatus& errorStatus);

GeneralResult<ExecutionPreference> unvalidatedConvert(

        const aidl_hal::ExecutionPreference& executionPreference);

GeneralResult<Extension> unvalidatedConvert(const aidl_hal::Extension& extension);

GeneralResult<Extension::OperandTypeInformation> unvalidatedConvert(

        const aidl_hal::ExtensionOperandTypeInformation& operandTypeInformation);

GeneralResult<SharedHandle> unvalidatedConvert(

        const ::aidl::android::hardware::common::NativeHandle& handle);



GeneralResult<ExecutionPreference> convert(

        const aidl_hal::ExecutionPreference& executionPreference);

GeneralResult<Memory> convert(const aidl_hal::Memory& memory);

GeneralResult<Model> convert(const aidl_hal::Model& model);

GeneralResult<Operand> convert(const aidl_hal::Operand& operand);

GeneralResult<OperandType> convert(const aidl_hal::OperandType& operandType);

GeneralResult<Priority> convert(const aidl_hal::Priority& priority);

GeneralResult<Request::MemoryPool> convert(const aidl_hal::RequestMemoryPool& memoryPool);

GeneralResult<Request> convert(const aidl_hal::Request& request);



GeneralResult<std::vector<Operation>> convert(const std::vector<aidl_hal::Operation>& outputShapes);

GeneralResult<std::vector<Memory>> convert(const std::vector<aidl_hal::Memory>& memories);



GeneralResult<std::vector<uint32_t>> toUnsigned(const std::vector<int32_t>& vec);



}  // namespace android::nn



namespace aidl::android::hardware::neuralnetworks::utils {



namespace nn = ::android::nn;



nn::GeneralResult<Memory> unvalidatedConvert(const nn::Memory& memory);

nn::GeneralResult<OutputShape> unvalidatedConvert(const nn::OutputShape& outputShape);

nn::GeneralResult<ErrorStatus> unvalidatedConvert(const nn::ErrorStatus& errorStatus);



nn::GeneralResult<Memory> convert(const nn::Memory& memory);

nn::GeneralResult<ErrorStatus> convert(const nn::ErrorStatus& errorStatus);

nn::GeneralResult<std::vector<OutputShape>> convert(

        const std::vector<nn::OutputShape>& outputShapes);



nn::GeneralResult<std::vector<int32_t>> toSigned(const std::vector<uint32_t>& vec);



}  // namespace aidl::android::hardware::neuralnetworks::utils



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_AIDL_CONVERSIONS_H

neuralnetworks/aidl/utils/include/nnapi/hal/aidl/Utils.h

0 → 100644
+54 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_AIDL_UTILS_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_AIDL_UTILS_H



#include "nnapi/hal/aidl/Conversions.h"



#include <android-base/logging.h>

#include <nnapi/Result.h>

#include <nnapi/Types.h>

#include <nnapi/Validation.h>



namespace aidl::android::hardware::neuralnetworks::utils {



constexpr auto kDefaultPriority = Priority::MEDIUM;

constexpr auto kVersion = nn::Version::ANDROID_S;



template <typename Type>

nn::Result<void> validate(const Type& halObject) {

    const auto maybeCanonical = nn::convert(halObject);

    if (!maybeCanonical.has_value()) {

        return nn::error() << maybeCanonical.error().message;

    }

    return {};

}



template <typename Type>

bool valid(const Type& halObject) {

    const auto result = utils::validate(halObject);

    if (!result.has_value()) {

        LOG(ERROR) << result.error();

    }

    return result.has_value();

}



nn::GeneralResult<Model> copyModel(const Model& model);



}  // namespace aidl::android::hardware::neuralnetworks::utils



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_AIDL_UTILS_H