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

Commit 7261ba7d authored by Michael Butler's avatar Michael Butler Committed by Gerrit Code Review
Browse files

Merge "NNAPI VTS update in response to utility function change"

parents 03d6f2fe 648ada5f

neuralnetworks/1.2/vts/functional/GeneratedTestHarness.cpp

+6 −2
Original line number Original line Diff line number Diff line
@@ -33,6 +33,7 @@ 




#include <gtest/gtest.h>

#include <gtest/gtest.h>

#include <algorithm>

#include <algorithm>

#include <chrono>

#include <iostream>

#include <iostream>

#include <numeric>

#include <numeric>
@@ -190,7 +191,8 @@ static Return<ErrorStatus> ExecutePreparedModel(const sp<IPreparedModel>& prepar 
}

}

static std::shared_ptr<::android::nn::ExecutionBurstController> CreateBurst(

static std::shared_ptr<::android::nn::ExecutionBurstController> CreateBurst(

        const sp<IPreparedModel>& preparedModel) {

        const sp<IPreparedModel>& preparedModel) {

    return android::nn::ExecutionBurstController::create(preparedModel, /*blocking=*/true);

    return android::nn::ExecutionBurstController::create(preparedModel,

                                                         std::chrono::microseconds{0});

}

}

enum class Executor { ASYNC, SYNC, BURST };

enum class Executor { ASYNC, SYNC, BURST };
@@ -254,8 +256,10 @@ void EvaluatePreparedModel(const sp<IPreparedModel>& preparedModel, const TestMo 
            }

            }





            // execute burst

            // execute burst

            std::tie(executionStatus, outputShapes, timing) =

            int n;

            std::tie(n, outputShapes, timing, std::ignore) =

                    controller->compute(request, measure, keys);

                    controller->compute(request, measure, keys);

            executionStatus = nn::convertResultCodeToErrorStatus(n);





            break;

            break;

        }

        }

neuralnetworks/1.2/vts/functional/ValidateBurst.cpp

+9 −4
Original line number Original line Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include "Utils.h"

#include "Utils.h"





#include <android-base/logging.h>

#include <android-base/logging.h>

#include <chrono>

#include <cstring>

#include <cstring>





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

namespace android::hardware::neuralnetworks::V1_2::vts::functional {
@@ -64,9 +65,9 @@ static void createBurst(const sp<IPreparedModel>& preparedModel, const sp<IBurst 




    // create FMQ objects

    // create FMQ objects

    auto [fmqRequestChannel, fmqRequestDescriptor] =

    auto [fmqRequestChannel, fmqRequestDescriptor] =

            RequestChannelSender::create(kExecutionBurstChannelLength, /*blocking=*/true);

            RequestChannelSender::create(kExecutionBurstChannelLength);

    auto [fmqResultChannel, fmqResultDescriptor] =

    auto [fmqResultChannel, fmqResultDescriptor] =

            ResultChannelReceiver::create(resultChannelLength, /*blocking=*/true);

            ResultChannelReceiver::create(resultChannelLength, std::chrono::microseconds{0});

    ASSERT_NE(nullptr, fmqRequestChannel.get());

    ASSERT_NE(nullptr, fmqRequestChannel.get());

    ASSERT_NE(nullptr, fmqResultChannel.get());

    ASSERT_NE(nullptr, fmqResultChannel.get());

    ASSERT_NE(nullptr, fmqRequestDescriptor);

    ASSERT_NE(nullptr, fmqRequestDescriptor);
@@ -293,8 +294,10 @@ static void validateBurstFmqLength(const sp<IPreparedModel>& preparedModel, 
    }

    }





    // collect serialized result by running regular burst

    // collect serialized result by running regular burst

    const auto [statusRegular, outputShapesRegular, timingRegular] =

    const auto [nRegular, outputShapesRegular, timingRegular, fallbackRegular] =

            controllerRegular->compute(request, MeasureTiming::NO, keys);

            controllerRegular->compute(request, MeasureTiming::NO, keys);

    const ErrorStatus statusRegular = nn::convertResultCodeToErrorStatus(nRegular);

    EXPECT_FALSE(fallbackRegular);





    // skip test if regular burst output isn't useful for testing a failure

    // skip test if regular burst output isn't useful for testing a failure

    // caused by having too small of a length for the result FMQ

    // caused by having too small of a length for the result FMQ
@@ -307,11 +310,13 @@ static void validateBurstFmqLength(const sp<IPreparedModel>& preparedModel, 




    // by this point, execution should fail because the result channel isn't

    // by this point, execution should fail because the result channel isn't

    // large enough to return the serialized result

    // large enough to return the serialized result

    const auto [statusSmall, outputShapesSmall, timingSmall] =

    const auto [nSmall, outputShapesSmall, timingSmall, fallbackSmall] =

            controllerSmall->compute(request, MeasureTiming::NO, keys);

            controllerSmall->compute(request, MeasureTiming::NO, keys);

    const ErrorStatus statusSmall = nn::convertResultCodeToErrorStatus(nSmall);

    EXPECT_NE(ErrorStatus::NONE, statusSmall);

    EXPECT_NE(ErrorStatus::NONE, statusSmall);

    EXPECT_EQ(0u, outputShapesSmall.size());

    EXPECT_EQ(0u, outputShapesSmall.size());

    EXPECT_TRUE(badTiming(timingSmall));

    EXPECT_TRUE(badTiming(timingSmall));

    EXPECT_FALSE(fallbackSmall);

}

}





static bool isSanitized(const FmqResultDatum& datum) {

static bool isSanitized(const FmqResultDatum& datum) {

neuralnetworks/1.2/vts/functional/ValidateRequest.cpp

+7 −6
Original line number Original line Diff line number Diff line
@@ -16,6 +16,7 @@ 




#define LOG_TAG "neuralnetworks_hidl_hal_test"

#define LOG_TAG "neuralnetworks_hidl_hal_test"





#include <chrono>

#include "1.0/Utils.h"

#include "1.0/Utils.h"

#include "1.2/Callbacks.h"

#include "1.2/Callbacks.h"

#include "ExecutionBurstController.h"

#include "ExecutionBurstController.h"
@@ -94,7 +95,8 @@ static void validate(const sp<IPreparedModel>& preparedModel, const std::string& 




        // create burst

        // create burst

        std::shared_ptr<::android::nn::ExecutionBurstController> burst =

        std::shared_ptr<::android::nn::ExecutionBurstController> burst =

                android::nn::ExecutionBurstController::create(preparedModel, /*blocking=*/true);

                android::nn::ExecutionBurstController::create(preparedModel,

                                                              std::chrono::microseconds{0});

        ASSERT_NE(nullptr, burst.get());

        ASSERT_NE(nullptr, burst.get());





        // create memory keys

        // create memory keys
@@ -104,13 +106,12 @@ static void validate(const sp<IPreparedModel>& preparedModel, const std::string& 
        }

        }





        // execute and verify

        // execute and verify

        ErrorStatus error;

        const auto [n, outputShapes, timing, fallback] = burst->compute(request, measure, keys);

        std::vector<OutputShape> outputShapes;

        const ErrorStatus status = nn::convertResultCodeToErrorStatus(n);

        Timing timing;

        EXPECT_EQ(ErrorStatus::INVALID_ARGUMENT, status);

        std::tie(error, outputShapes, timing) = burst->compute(request, measure, keys);

        EXPECT_EQ(ErrorStatus::INVALID_ARGUMENT, error);

        EXPECT_EQ(outputShapes.size(), 0);

        EXPECT_EQ(outputShapes.size(), 0);

        EXPECT_TRUE(badTiming(timing));

        EXPECT_TRUE(badTiming(timing));

        EXPECT_FALSE(fallback);





        // additional burst testing

        // additional burst testing

        if (request.pools.size() > 0) {

        if (request.pools.size() > 0) {

neuralnetworks/1.3/vts/functional/GeneratedTestHarness.cpp

+6 −2
Original line number Original line Diff line number Diff line
@@ -36,6 +36,7 @@ 




#include <gtest/gtest.h>

#include <gtest/gtest.h>

#include <algorithm>

#include <algorithm>

#include <chrono>

#include <iostream>

#include <iostream>

#include <numeric>

#include <numeric>
@@ -200,7 +201,8 @@ static Return<ErrorStatus> ExecutePreparedModel(const sp<IPreparedModel>& prepar 
}

}

static std::shared_ptr<::android::nn::ExecutionBurstController> CreateBurst(

static std::shared_ptr<::android::nn::ExecutionBurstController> CreateBurst(

        const sp<IPreparedModel>& preparedModel) {

        const sp<IPreparedModel>& preparedModel) {

    return android::nn::ExecutionBurstController::create(preparedModel, /*blocking=*/true);

    return android::nn::ExecutionBurstController::create(preparedModel,

                                                         std::chrono::microseconds{0});

}

}

enum class Executor { ASYNC, SYNC, BURST };

enum class Executor { ASYNC, SYNC, BURST };
@@ -264,8 +266,10 @@ void EvaluatePreparedModel(const sp<IPreparedModel>& preparedModel, const TestMo 
            }

            }





            // execute burst

            // execute burst

            std::tie(executionStatus, outputShapes, timing) =

            int n;

            std::tie(n, outputShapes, timing, std::ignore) =

                    controller->compute(request, measure, keys);

                    controller->compute(request, measure, keys);

            executionStatus = nn::convertResultCodeToErrorStatus(n);





            break;

            break;

        }

        }

neuralnetworks/1.3/vts/functional/ValidateBurst.cpp

+9 −4
Original line number Original line Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include "Utils.h"

#include "Utils.h"





#include <android-base/logging.h>

#include <android-base/logging.h>

#include <chrono>

#include <cstring>

#include <cstring>





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

namespace android::hardware::neuralnetworks::V1_3::vts::functional {
@@ -71,9 +72,9 @@ static void createBurst(const sp<IPreparedModel>& preparedModel, const sp<IBurst 




    // create FMQ objects

    // create FMQ objects

    auto [fmqRequestChannel, fmqRequestDescriptor] =

    auto [fmqRequestChannel, fmqRequestDescriptor] =

            RequestChannelSender::create(kExecutionBurstChannelLength, /*blocking=*/true);

            RequestChannelSender::create(kExecutionBurstChannelLength);

    auto [fmqResultChannel, fmqResultDescriptor] =

    auto [fmqResultChannel, fmqResultDescriptor] =

            ResultChannelReceiver::create(resultChannelLength, /*blocking=*/true);

            ResultChannelReceiver::create(resultChannelLength, std::chrono::microseconds{0});

    ASSERT_NE(nullptr, fmqRequestChannel.get());

    ASSERT_NE(nullptr, fmqRequestChannel.get());

    ASSERT_NE(nullptr, fmqResultChannel.get());

    ASSERT_NE(nullptr, fmqResultChannel.get());

    ASSERT_NE(nullptr, fmqRequestDescriptor);

    ASSERT_NE(nullptr, fmqRequestDescriptor);
@@ -300,8 +301,10 @@ static void validateBurstFmqLength(const sp<IPreparedModel>& preparedModel, 
    }

    }





    // collect serialized result by running regular burst

    // collect serialized result by running regular burst

    const auto [statusRegular, outputShapesRegular, timingRegular] =

    const auto [nRegular, outputShapesRegular, timingRegular, fallbackRegular] =

            controllerRegular->compute(request, MeasureTiming::NO, keys);

            controllerRegular->compute(request, MeasureTiming::NO, keys);

    const ErrorStatus statusRegular = nn::convertResultCodeToErrorStatus(nRegular);

    EXPECT_FALSE(fallbackRegular);





    // skip test if regular burst output isn't useful for testing a failure

    // skip test if regular burst output isn't useful for testing a failure

    // caused by having too small of a length for the result FMQ

    // caused by having too small of a length for the result FMQ
@@ -314,11 +317,13 @@ static void validateBurstFmqLength(const sp<IPreparedModel>& preparedModel, 




    // by this point, execution should fail because the result channel isn't

    // by this point, execution should fail because the result channel isn't

    // large enough to return the serialized result

    // large enough to return the serialized result

    const auto [statusSmall, outputShapesSmall, timingSmall] =

    const auto [nSmall, outputShapesSmall, timingSmall, fallbackSmall] =

            controllerSmall->compute(request, MeasureTiming::NO, keys);

            controllerSmall->compute(request, MeasureTiming::NO, keys);

    const ErrorStatus statusSmall = nn::convertResultCodeToErrorStatus(nSmall);

    EXPECT_NE(ErrorStatus::NONE, statusSmall);

    EXPECT_NE(ErrorStatus::NONE, statusSmall);

    EXPECT_EQ(0u, outputShapesSmall.size());

    EXPECT_EQ(0u, outputShapesSmall.size());

    EXPECT_TRUE(badTiming(timingSmall));

    EXPECT_TRUE(badTiming(timingSmall));

    EXPECT_FALSE(fallbackSmall);

}

}





static bool isSanitized(const FmqResultDatum& datum) {

static bool isSanitized(const FmqResultDatum& datum) {