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

Commit 543606fb authored by Lev Proleev's avatar Lev Proleev
Browse files

Modify NNAPI VTS tests to run on version 1.3 

Bug: 139120468
Test: VtsHalNeuralnetworksV1_3TargetTest
Change-Id: Id9e4d99852da8a3d5167ab7464c0e71885250501
Merged-In: Id9e4d99852da8a3d5167ab7464c0e71885250501
(cherry picked from commit b49dadfb)
parent d0e339e1

neuralnetworks/1.2/vts/functional/Android.bp

+18 −1
Original line number Diff line number Diff line
@@ -14,12 +14,28 @@ 
// limitations under the License.

//



cc_library_static {

    name: "VtsHalNeuralNetworksV1_2Callbacks",

    defaults: ["VtsHalTargetTestDefaults"],

    export_include_dirs: ["include"],

    srcs: [

        "Callbacks.cpp",

    ],

    static_libs: [

        "android.hardware.neuralnetworks@1.0",

        "android.hardware.neuralnetworks@1.1",

        "android.hardware.neuralnetworks@1.2",

    ],

    header_libs: [

        "libbase_headers",

    ]

}



cc_test {

    name: "VtsHalNeuralnetworksV1_2TargetTest",

    defaults: ["VtsHalTargetTestDefaults"],

    srcs: [

        "BasicTests.cpp",

        "Callbacks.cpp",

        "CompilationCachingTests.cpp",

        "GeneratedTestHarness.cpp",

        "TestAssertions.cpp",
@@ -45,6 +61,7 @@ cc_test { 
        "libneuralnetworks_generated_test_harness",

        "libneuralnetworks_utils",

        "VtsHalNeuralNetworksV1_0_utils",

        "VtsHalNeuralNetworksV1_2Callbacks",

    ],

    whole_static_libs: [

        "neuralnetworks_generated_V1_0_example",

neuralnetworks/1.3/vts/functional/Android.bp

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

// Copyright (C) 2019 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: "VtsHalNeuralNetworksV1_3TargetTest",

    defaults: ["VtsHalTargetTestDefaults"],

    srcs: [

        "BasicTests.cpp",

        "CompilationCachingTests.cpp",

        "GeneratedTestHarness.cpp",

        "TestAssertions.cpp",

        "ValidateBurst.cpp",

        "ValidateModel.cpp",

        "ValidateRequest.cpp",

        "VtsHalNeuralnetworks.cpp",

    ],

    shared_libs: [

        "libfmq",

        "libnativewindow",

    ],

    static_libs: [

        "android.hardware.neuralnetworks@1.0",

        "android.hardware.neuralnetworks@1.1",

        "android.hardware.neuralnetworks@1.2",

        "android.hardware.neuralnetworks@1.3",

        "android.hidl.allocator@1.0",

        "android.hidl.memory@1.0",

        "libgmock",

        "libhidlmemory",

        "libneuralnetworks_generated_test_harness",

        "libneuralnetworks_utils",

        "VtsHalNeuralNetworksV1_0_utils",

        "VtsHalNeuralNetworksV1_2Callbacks",

    ],

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

        "libneuralnetworks_headers",

    ],

    test_suites: ["general-tests"],

}

neuralnetworks/1.3/vts/functional/BasicTests.cpp

+6 −56
Original line number Diff line number Diff line
@@ -18,11 +18,14 @@ 


#include "VtsHalNeuralnetworks.h"



namespace android::hardware::neuralnetworks::V1_2::vts::functional {

namespace android::hardware::neuralnetworks::V1_3::vts::functional {



using V1_0::DeviceStatus;

using V1_0::ErrorStatus;

using V1_0::PerformanceInfo;

using V1_2::Constant;

using V1_2::DeviceType;

using V1_2::Extension;



// create device test

TEST_P(NeuralnetworksHidlTest, CreateDevice) {}
@@ -37,7 +40,7 @@ TEST_P(NeuralnetworksHidlTest, StatusTest) { 
// initialization

TEST_P(NeuralnetworksHidlTest, GetCapabilitiesTest) {

    using OperandPerformance = Capabilities::OperandPerformance;

    Return<void> ret = kDevice->getCapabilities_1_2([](ErrorStatus status,

    Return<void> ret = kDevice->getCapabilities_1_3([](ErrorStatus status,

                                                       const Capabilities& capabilities) {

        EXPECT_EQ(ErrorStatus::NONE, status);
@@ -58,57 +61,4 @@ TEST_P(NeuralnetworksHidlTest, GetCapabilitiesTest) { 
    });

    EXPECT_TRUE(ret.isOk());

}



// device version test

TEST_P(NeuralnetworksHidlTest, GetDeviceVersionStringTest) {

    Return<void> ret =

            kDevice->getVersionString([](ErrorStatus status, const hidl_string& version) {

                EXPECT_EQ(ErrorStatus::NONE, status);

                EXPECT_LT(0, version.size());

            });

    EXPECT_TRUE(ret.isOk());

}



// device type test

TEST_P(NeuralnetworksHidlTest, GetDeviceTypeTest) {

    Return<void> ret = kDevice->getType([](ErrorStatus status, DeviceType type) {

        EXPECT_EQ(ErrorStatus::NONE, status);

        EXPECT_TRUE(type == DeviceType::OTHER || type == DeviceType::CPU ||

                    type == DeviceType::GPU || type == DeviceType::ACCELERATOR);

    });

    EXPECT_TRUE(ret.isOk());

}



// device supported extensions test

TEST_P(NeuralnetworksHidlTest, GetDeviceSupportedExtensionsTest) {

    Return<void> ret = kDevice->getSupportedExtensions(

            [](ErrorStatus status, const hidl_vec<Extension>& extensions) {

                EXPECT_EQ(ErrorStatus::NONE, status);

                for (auto& extension : extensions) {

                    std::string extensionName = extension.name;

                    EXPECT_FALSE(extensionName.empty());

                    for (char c : extensionName) {

                        EXPECT_TRUE(('a' <= c && c <= 'z') || ('0' <= c && c <= '9') || c == '_' ||

                                    c == '.')

                                << "Extension name contains an illegal character: " << c;

                    }

                    EXPECT_NE(extensionName.find('.'), std::string::npos)

                            << "Extension name must start with the reverse domain name of the "

                               "vendor";

                }

            });

    EXPECT_TRUE(ret.isOk());

}



// getNumberOfCacheFilesNeeded test

TEST_P(NeuralnetworksHidlTest, getNumberOfCacheFilesNeeded) {

    Return<void> ret = kDevice->getNumberOfCacheFilesNeeded(

            [](ErrorStatus status, uint32_t numModelCache, uint32_t numDataCache) {

                EXPECT_EQ(ErrorStatus::NONE, status);

                EXPECT_LE(numModelCache,

                          static_cast<uint32_t>(Constant::MAX_NUMBER_OF_CACHE_FILES));

                EXPECT_LE(numDataCache, static_cast<uint32_t>(Constant::MAX_NUMBER_OF_CACHE_FILES));

            });

    EXPECT_TRUE(ret.isOk());

}

}  // namespace android::hardware::neuralnetworks::V1_2::vts::functional
 
}  // namespace android::hardware::neuralnetworks::V1_3::vts::functional

neuralnetworks/1.3/vts/functional/Callbacks.cpp

deleted100644 → 0
+0 −143
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 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.

 */



#define LOG_TAG "Callbacks"



#include "1.2/Callbacks.h"



#include <android-base/logging.h>



#include <limits>



namespace android::hardware::neuralnetworks::V1_2::implementation {



using V1_0::ErrorStatus;



constexpr Timing kNoTiming = {.timeOnDevice = std::numeric_limits<uint64_t>::max(),

                              .timeInDriver = std::numeric_limits<uint64_t>::max()};



// PreparedModelCallback methods begin here



Return<void> PreparedModelCallback::notify(ErrorStatus errorStatus,

                                           const sp<V1_0::IPreparedModel>& preparedModel) {

    {

        std::lock_guard<std::mutex> hold(mMutex);



        // quick-return if object has already been notified

        if (mNotified) {

            return Void();

        }



        // store results and mark as notified

        mErrorStatus = errorStatus;

        mPreparedModel = preparedModel;

        mNotified = true;

    }



    mCondition.notify_all();

    return Void();

}



Return<void> PreparedModelCallback::notify_1_2(ErrorStatus errorStatus,

                                               const sp<V1_2::IPreparedModel>& preparedModel) {

    return notify(errorStatus, preparedModel);

}



void PreparedModelCallback::wait() const {

    std::unique_lock<std::mutex> lock(mMutex);

    mCondition.wait(lock, [this] { return mNotified; });

}



ErrorStatus PreparedModelCallback::getStatus() const {

    wait();

    return mErrorStatus;

}



sp<V1_0::IPreparedModel> PreparedModelCallback::getPreparedModel() const {

    wait();

    return mPreparedModel;

}



// ExecutionCallback methods begin here



Return<void> ExecutionCallback::notify(ErrorStatus errorStatus) {

    notifyInternal(errorStatus, {}, kNoTiming);

    return Void();

}



Return<void> ExecutionCallback::notify_1_2(ErrorStatus errorStatus,

                                           const hidl_vec<OutputShape>& outputShapes,

                                           const Timing& timing) {

    if (errorStatus == ErrorStatus::OUTPUT_INSUFFICIENT_SIZE) {

        // outputShapes must not be empty if OUTPUT_INSUFFICIENT_SIZE.

        if (outputShapes.size() == 0) {

            LOG(ERROR) << "Notified with empty output shape vector when OUTPUT_INSUFFICIENT_SIZE";

            notifyInternal(ErrorStatus::GENERAL_FAILURE, {}, kNoTiming);

            return Void();

        }

    } else if (errorStatus != ErrorStatus::NONE) {

        // outputShapes must be empty if errorStatus is neither NONE nor OUTPUT_INSUFFICIENT_SIZE.

        if (outputShapes.size() != 0) {

            LOG(ERROR) << "Notified with non-empty output shape vector when error status is "

                          "neither NONE nor OUTPUT_INSUFFICIENT_SIZE";

            notifyInternal(ErrorStatus::GENERAL_FAILURE, {}, kNoTiming);

            return Void();

        }

    }

    notifyInternal(errorStatus, outputShapes, timing);

    return Void();

}



void ExecutionCallback::wait() const {

    std::unique_lock<std::mutex> lock(mMutex);

    mCondition.wait(lock, [this] { return mNotified; });

}



ErrorStatus ExecutionCallback::getStatus() const {

    wait();

    return mErrorStatus;

}



const std::vector<OutputShape>& ExecutionCallback::getOutputShapes() const {

    wait();

    return mOutputShapes;

}



Timing ExecutionCallback::getTiming() const {

    wait();

    return mTiming;

}



void ExecutionCallback::notifyInternal(ErrorStatus errorStatus,

                                       const hidl_vec<OutputShape>& outputShapes,

                                       const Timing& timing) {

    {

        std::lock_guard<std::mutex> hold(mMutex);



        // quick-return if object has already been notified

        if (mNotified) {

            return;

        }



        mErrorStatus = errorStatus;

        mOutputShapes = outputShapes;

        mTiming = timing;

        mNotified = true;

    }

    mCondition.notify_all();

}



}  // namespace android::hardware::neuralnetworks::V1_2::implementation

neuralnetworks/1.3/vts/functional/CompilationCachingTests.cpp

+8 −5
Original line number Diff line number Diff line
@@ -45,12 +45,15 @@ namespace generated_tests::mobilenet_quantized { 
const test_helper::TestModel& get_test_model();

}  // namespace generated_tests::mobilenet_quantized



namespace android::hardware::neuralnetworks::V1_2::vts::functional {

namespace android::hardware::neuralnetworks::V1_3::vts::functional {



using namespace test_helper;

using implementation::PreparedModelCallback;

using V1_0::ErrorStatus;

using V1_1::ExecutionPreference;

using V1_2::Constant;

using V1_2::IPreparedModel;

using V1_2::OperationType;

using V1_2::implementation::PreparedModelCallback;



namespace float32_model {
@@ -302,7 +305,7 @@ class CompilationCachingTestBase : public testing::Test { 
    // See if the service can handle the model.

    bool isModelFullySupported(const Model& model) {

        bool fullySupportsModel = false;

        Return<void> supportedCall = kDevice->getSupportedOperations_1_2(

        Return<void> supportedCall = kDevice->getSupportedOperations_1_3(

                model,

                [&fullySupportsModel, &model](ErrorStatus status, const hidl_vec<bool>& supported) {

                    ASSERT_EQ(ErrorStatus::NONE, status);
@@ -323,7 +326,7 @@ class CompilationCachingTestBase : public testing::Test { 
        sp<PreparedModelCallback> preparedModelCallback = new PreparedModelCallback();

        hidl_array<uint8_t, sizeof(mToken)> cacheToken(mToken);

        Return<ErrorStatus> prepareLaunchStatus =

                kDevice->prepareModel_1_2(model, ExecutionPreference::FAST_SINGLE_ANSWER,

                kDevice->prepareModel_1_3(model, ExecutionPreference::FAST_SINGLE_ANSWER,

                                          modelCache, dataCache, cacheToken, preparedModelCallback);

        ASSERT_TRUE(prepareLaunchStatus.isOk());

        ASSERT_EQ(static_cast<ErrorStatus>(prepareLaunchStatus), ErrorStatus::NONE);
@@ -1371,4 +1374,4 @@ INSTANTIATE_TEST_CASE_P(TestCompilationCaching, CompilationCachingSecurityTest, 
                                         testing::Range(0U, 10U)),

                        printCompilationCachingSecurityTest);



}  // namespace android::hardware::neuralnetworks::V1_2::vts::functional
 
}  // namespace android::hardware::neuralnetworks::V1_3::vts::functional