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

Commit c185e88c authored by Lev Proleev's avatar Lev Proleev
Browse files

Implement VTS tests for NNAPI AIDL interface 

The tests are copied from HIDL 1.0-3 VTS tests and updated to use AIDL.

Bug: 172922059
Test: VtsHalNeuralnetworksTargetTest
Change-Id: Ife08409e9b46420685a1ccb0b3256286c973dbf5
Merged-In: Ife08409e9b46420685a1ccb0b3256286c973dbf5
(cherry picked from commit b38bb4f1)
parent 6b6dfcd4

neuralnetworks/1.3/vts/functional/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -57,6 +57,7 @@ cc_test { 
        "VtsHalNeuralNetworksV1_0_utils",

        "VtsHalNeuralNetworksV1_2_utils",

        "VtsHalNeuralNetworksV1_3_utils",

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

        "android.hardware.neuralnetworks@1.0",

        "android.hardware.neuralnetworks@1.1",

        "android.hardware.neuralnetworks@1.2",

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

+4 −1
Original line number Diff line number Diff line
@@ -47,7 +47,10 @@ bool valid(const Type& halObject) { 
    return result.has_value();

}



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

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

nn::GeneralResult<Request> clone(const Request& request);

nn::GeneralResult<RequestMemoryPool> clone(const RequestMemoryPool& requestPool);

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



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

neuralnetworks/aidl/utils/src/Utils.cpp

+62 −23
Original line number Diff line number Diff line
@@ -19,38 +19,77 @@ 
#include <nnapi/Result.h>



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

namespace {



using ::android::nn::GeneralResult;



GeneralResult<Model> copyModel(const Model& model) {

    Model newModel{

            .main = model.main,

            .referenced = model.referenced,

            .operandValues = model.operandValues,

            .pools = {},

            .relaxComputationFloat32toFloat16 = model.relaxComputationFloat32toFloat16,

            .extensionNameToPrefix = model.extensionNameToPrefix,

    };

    newModel.pools.reserve(model.pools.size());

    for (const auto& pool : model.pools) {

template <typename Type>

nn::GeneralResult<std::vector<Type>> cloneVec(const std::vector<Type>& arguments) {

    std::vector<Type> clonedObjects;

    clonedObjects.reserve(arguments.size());

    for (const auto& argument : arguments) {

        clonedObjects.push_back(NN_TRY(clone(argument)));

    }

    return clonedObjects;

}



template <typename Type>

GeneralResult<std::vector<Type>> clone(const std::vector<Type>& arguments) {

    return cloneVec(arguments);

}



}  // namespace



GeneralResult<Memory> clone(const Memory& memory) {

    common::NativeHandle nativeHandle;

        nativeHandle.ints = pool.handle.ints;

        nativeHandle.fds.reserve(pool.handle.fds.size());

        for (const auto& fd : pool.handle.fds) {

    nativeHandle.ints = memory.handle.ints;

    nativeHandle.fds.reserve(memory.handle.fds.size());

    for (const auto& fd : memory.handle.fds) {

        const int newFd = dup(fd.get());

            if (newFd == -1) {

                return NN_ERROR() << "Couldn't dup a file descriptor.";

        if (newFd < 0) {

            return NN_ERROR() << "Couldn't dup a file descriptor";

        }

        nativeHandle.fds.emplace_back(newFd);

    }

        Memory memory = {

    return Memory{

            .handle = std::move(nativeHandle),

                .size = pool.size,

                .name = pool.name,

            .size = memory.size,

            .name = memory.name,

    };

        newModel.pools.push_back(std::move(memory));

}

    return newModel;



GeneralResult<RequestMemoryPool> clone(const RequestMemoryPool& requestPool) {

    using Tag = RequestMemoryPool::Tag;

    switch (requestPool.getTag()) {

        case Tag::pool:

            return RequestMemoryPool::make<Tag::pool>(NN_TRY(clone(requestPool.get<Tag::pool>())));

        case Tag::token:

            return RequestMemoryPool::make<Tag::token>(requestPool.get<Tag::token>());

    }

    // Using explicit type conversion because std::variant inside the RequestMemoryPool confuses the

    // compiler.

    return (NN_ERROR() << "Unrecognized request pool tag: " << requestPool.getTag())

            .

            operator GeneralResult<RequestMemoryPool>();

}



GeneralResult<Request> clone(const Request& request) {

    return Request{

            .inputs = request.inputs,

            .outputs = request.outputs,

            .pools = NN_TRY(clone(request.pools)),

    };

}



GeneralResult<Model> clone(const Model& model) {

    return Model{

            .main = model.main,

            .referenced = model.referenced,

            .operandValues = model.operandValues,

            .pools = NN_TRY(clone(model.pools)),

            .relaxComputationFloat32toFloat16 = model.relaxComputationFloat32toFloat16,

            .extensionNameToPrefix = model.extensionNameToPrefix,

    };

}



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

neuralnetworks/aidl/vts/OWNERS

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

butlermichael@google.com

dgross@google.com

jeanluc@google.com

levp@google.com

miaowang@google.com

mikie@google.com

mks@google.com

pszczepaniak@google.com

slavash@google.com

vddang@google.com

xusongw@google.com

neuralnetworks/aidl/vts/functional/Android.bp

0 → 100644
+68 −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_test {

    name: "VtsHalNeuralnetworksTargetTest",

    defaults: [

        "neuralnetworks_vts_functional_defaults",

        "use_libaidlvintf_gtest_helper_static",

    ],

    srcs: [

        "BasicTests.cpp",

        "Callbacks.cpp",

        "CompilationCachingTests.cpp",

        "GeneratedTestHarness.cpp",

        "MemoryDomainTests.cpp",

        "QualityOfServiceTests.cpp",

        "TestAssertions.cpp",

        "TestMain.cpp",

        "Utils.cpp",

        "ValidateModel.cpp",

        "ValidateRequest.cpp",

        "VtsHalNeuralnetworks.cpp",

    ],

    shared_libs: [

        "libbinder_ndk",

        "libnativewindow",

        "libvndksupport",

    ],

    static_libs: [

        "android.hardware.common-V2-ndk_platform",

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

        "android.hidl.allocator@1.0",

        "android.hidl.memory@1.0",

        "libgmock",

        "libhidlmemory",

        "libneuralnetworks_generated_test_harness",

        "libneuralnetworks_utils",

        "libsync",

        "neuralnetworks_utils_hal_aidl",

    ],

    whole_static_libs: [

        "neuralnetworks_generated_V1_0_example",

        "neuralnetworks_generated_V1_1_example",

        "neuralnetworks_generated_V1_2_example",

        "neuralnetworks_generated_V1_3_example",

    ],

    header_libs: [

        "libbase_headers",

        "libneuralnetworks_headers",

    ],

    test_suites: [

        "general-tests",

        "vts",

    ],

}