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

Commit 12bd88cf authored by Xusong Wang's avatar Xusong Wang Committed by Automerger Merge Worker
Browse files

Merge "Revert "Allow compilations in TOCTOU tests to fail with... 

Merge "Revert "Allow compilations in TOCTOU tests to fail with GENERAL_FAILURE."" into rvc-dev am: 12f483fd am: 428d3771

Original change: https://googleplex-android-review.googlesource.com/c/platform/hardware/interfaces/+/11953061

Change-Id: I762fe1ca5fae392f68c7cc9b5a6ffc6fcb7da5ea
parents 02e8cc07 428d3771

neuralnetworks/1.2/vts/functional/CompilationCachingTests.cpp

+9 −38
Original line number Diff line number Diff line
@@ -315,8 +315,7 @@ class CompilationCachingTestBase : public testing::Test { 


    void saveModelToCache(const Model& model, const hidl_vec<hidl_handle>& modelCache,

                          const hidl_vec<hidl_handle>& dataCache,

                          sp<IPreparedModel>* preparedModel = nullptr,

                          bool allowGeneralFailure = false) {

                          sp<IPreparedModel>* preparedModel = nullptr) {

        if (preparedModel != nullptr) *preparedModel = nullptr;



        // Launch prepare model.
@@ -330,10 +329,7 @@ class CompilationCachingTestBase : public testing::Test { 


        // Retrieve prepared model.

        preparedModelCallback->wait();

        const auto prepareCallbackStatus = preparedModelCallback->getStatus();

        if (!allowGeneralFailure || prepareCallbackStatus != ErrorStatus::GENERAL_FAILURE) {

            ASSERT_EQ(prepareCallbackStatus, ErrorStatus::NONE);

        }

        ASSERT_EQ(preparedModelCallback->getStatus(), ErrorStatus::NONE);

        if (preparedModel != nullptr) {

            *preparedModel = IPreparedModel::castFrom(preparedModelCallback->getPreparedModel())

                                     .withDefault(nullptr);
@@ -1026,8 +1022,7 @@ static void copyCacheFiles(const std::vector<std::vector<std::string>>& from, 


// Number of operations in the large test model.

constexpr uint32_t kLargeModelSize = 100;

constexpr uint32_t kNumSuccessfulIterationsTOCTOU = 100;

constexpr uint32_t kMaxNumFailedIterationsTOCTOU = 100;

constexpr uint32_t kNumIterationsTOCTOU = 100;



TEST_P(CompilationCachingTest, SaveToCache_TOCTOU) {

    if (!mIsCachingSupported) return;
@@ -1055,30 +1050,18 @@ TEST_P(CompilationCachingTest, SaveToCache_TOCTOU) { 
    // Use a different token for modelAdd.

    mToken[0]++;



    // This test is probabilistic, so we run it multiple times. We allow the compilation to fail

    // because it is not related to the security aspect of the TOCTOU test. However, we need to have

    // enough successful iterations to ensure the test coverage.

    uint32_t numSuccessfulIterations = 0, numFailedIterations = 0;

    while (numSuccessfulIterations < kNumSuccessfulIterationsTOCTOU) {

    // This test is probabilistic, so we run it multiple times.

    for (uint32_t i = 0; i < kNumIterationsTOCTOU; i++) {

        // Save the modelAdd compilation to cache.

        {

            hidl_vec<hidl_handle> modelCache, dataCache;

            createCacheHandles(mModelCache, AccessMode::READ_WRITE, &modelCache);

            createCacheHandles(mDataCache, AccessMode::READ_WRITE, &dataCache);



            sp<IPreparedModel> preparedModel = nullptr;

            // Spawn a thread to copy the cache content concurrently while saving to cache.

            std::thread thread(copyCacheFiles, std::cref(modelCacheMul), std::cref(mModelCache));

            saveModelToCache(modelAdd, modelCache, dataCache, &preparedModel,

                             /*allowGeneralFailure=*/true);

            saveModelToCache(modelAdd, modelCache, dataCache);

            thread.join();



            if (preparedModel == nullptr) {

                numFailedIterations++;

                ASSERT_LE(numFailedIterations, kMaxNumFailedIterationsTOCTOU);

            } else {

                numSuccessfulIterations++;

            }

        }



        // Retrieve preparedModel from cache.
@@ -1129,26 +1112,14 @@ TEST_P(CompilationCachingTest, PrepareFromCache_TOCTOU) { 
    // Use a different token for modelAdd.

    mToken[0]++;



    // This test is probabilistic, so we run it multiple times. We allow the compilation to fail

    // because it is not related to the security aspect of the TOCTOU test. However, we need to have

    // enough successful iterations to ensure the test coverage.

    uint32_t numSuccessfulIterations = 0, numFailedIterations = 0;

    while (numSuccessfulIterations < kNumSuccessfulIterationsTOCTOU) {

    // This test is probabilistic, so we run it multiple times.

    for (uint32_t i = 0; i < kNumIterationsTOCTOU; i++) {

        // Save the modelAdd compilation to cache.

        {

            hidl_vec<hidl_handle> modelCache, dataCache;

            createCacheHandles(mModelCache, AccessMode::READ_WRITE, &modelCache);

            createCacheHandles(mDataCache, AccessMode::READ_WRITE, &dataCache);

            sp<IPreparedModel> preparedModel = nullptr;

            saveModelToCache(modelAdd, modelCache, dataCache, &preparedModel,

                             /*allowGeneralFailure=*/true);



            if (preparedModel == nullptr) {

                numFailedIterations++;

                ASSERT_LE(numFailedIterations, kMaxNumFailedIterationsTOCTOU);

            } else {

                numSuccessfulIterations++;

            }

            saveModelToCache(modelAdd, modelCache, dataCache);

        }



        // Retrieve preparedModel from cache.

neuralnetworks/1.3/vts/functional/CompilationCachingTests.cpp

+9 −38
Original line number Diff line number Diff line
@@ -318,8 +318,7 @@ class CompilationCachingTestBase : public testing::Test { 


    void saveModelToCache(const Model& model, const hidl_vec<hidl_handle>& modelCache,

                          const hidl_vec<hidl_handle>& dataCache,

                          sp<IPreparedModel>* preparedModel = nullptr,

                          bool allowGeneralFailure = false) {

                          sp<IPreparedModel>* preparedModel = nullptr) {

        if (preparedModel != nullptr) *preparedModel = nullptr;



        // Launch prepare model.
@@ -333,10 +332,7 @@ class CompilationCachingTestBase : public testing::Test { 


        // Retrieve prepared model.

        preparedModelCallback->wait();

        const auto prepareCallbackStatus = preparedModelCallback->getStatus();

        if (!allowGeneralFailure || prepareCallbackStatus != ErrorStatus::GENERAL_FAILURE) {

            ASSERT_EQ(prepareCallbackStatus, ErrorStatus::NONE);

        }

        ASSERT_EQ(preparedModelCallback->getStatus(), ErrorStatus::NONE);

        if (preparedModel != nullptr) {

            *preparedModel = IPreparedModel::castFrom(preparedModelCallback->getPreparedModel())

                                     .withDefault(nullptr);
@@ -1017,8 +1013,7 @@ static void copyCacheFiles(const std::vector<std::vector<std::string>>& from, 


// Number of operations in the large test model.

constexpr uint32_t kLargeModelSize = 100;

constexpr uint32_t kNumSuccessfulIterationsTOCTOU = 100;

constexpr uint32_t kMaxNumFailedIterationsTOCTOU = 100;

constexpr uint32_t kNumIterationsTOCTOU = 100;



TEST_P(CompilationCachingTest, SaveToCache_TOCTOU) {

    if (!mIsCachingSupported) return;
@@ -1046,30 +1041,18 @@ TEST_P(CompilationCachingTest, SaveToCache_TOCTOU) { 
    // Use a different token for modelAdd.

    mToken[0]++;



    // This test is probabilistic, so we run it multiple times. We allow the compilation to fail

    // because it is not related to the security aspect of the TOCTOU test. However, we need to have

    // enough successful iterations to ensure the test coverage.

    uint32_t numSuccessfulIterations = 0, numFailedIterations = 0;

    while (numSuccessfulIterations < kNumSuccessfulIterationsTOCTOU) {

    // This test is probabilistic, so we run it multiple times.

    for (uint32_t i = 0; i < kNumIterationsTOCTOU; i++) {

        // Save the modelAdd compilation to cache.

        {

            hidl_vec<hidl_handle> modelCache, dataCache;

            createCacheHandles(mModelCache, AccessMode::READ_WRITE, &modelCache);

            createCacheHandles(mDataCache, AccessMode::READ_WRITE, &dataCache);



            sp<IPreparedModel> preparedModel = nullptr;

            // Spawn a thread to copy the cache content concurrently while saving to cache.

            std::thread thread(copyCacheFiles, std::cref(modelCacheMul), std::cref(mModelCache));

            saveModelToCache(modelAdd, modelCache, dataCache, &preparedModel,

                             /*allowGeneralFailure=*/true);

            saveModelToCache(modelAdd, modelCache, dataCache);

            thread.join();



            if (preparedModel == nullptr) {

                numFailedIterations++;

                ASSERT_LE(numFailedIterations, kMaxNumFailedIterationsTOCTOU);

            } else {

                numSuccessfulIterations++;

            }

        }



        // Retrieve preparedModel from cache.
@@ -1120,26 +1103,14 @@ TEST_P(CompilationCachingTest, PrepareFromCache_TOCTOU) { 
    // Use a different token for modelAdd.

    mToken[0]++;



    // This test is probabilistic, so we run it multiple times. We allow the compilation to fail

    // because it is not related to the security aspect of the TOCTOU test. However, we need to have

    // enough successful iterations to ensure the test coverage.

    uint32_t numSuccessfulIterations = 0, numFailedIterations = 0;

    while (numSuccessfulIterations < kNumSuccessfulIterationsTOCTOU) {

    // This test is probabilistic, so we run it multiple times.

    for (uint32_t i = 0; i < kNumIterationsTOCTOU; i++) {

        // Save the modelAdd compilation to cache.

        {

            hidl_vec<hidl_handle> modelCache, dataCache;

            createCacheHandles(mModelCache, AccessMode::READ_WRITE, &modelCache);

            createCacheHandles(mDataCache, AccessMode::READ_WRITE, &dataCache);

            sp<IPreparedModel> preparedModel = nullptr;

            saveModelToCache(modelAdd, modelCache, dataCache, &preparedModel,

                             /*allowGeneralFailure=*/true);



            if (preparedModel == nullptr) {

                numFailedIterations++;

                ASSERT_LE(numFailedIterations, kMaxNumFailedIterationsTOCTOU);

            } else {

                numSuccessfulIterations++;

            }

            saveModelToCache(modelAdd, modelCache, dataCache);

        }



        // Retrieve preparedModel from cache.