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

Commit 2ebfa337 authored by Xusong Wang's avatar Xusong Wang Committed by Automerger Merge Worker
Browse files

Merge "Test readonly request input in AIDL VTS." into sc-dev am: f78c3ec5 

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

Change-Id: I0860c6a405d76b37ee1de079f5724d723ce39998
parents c4cd2704 f78c3ec5

neuralnetworks/aidl/vts/functional/GeneratedTestHarness.cpp

+2 −2
Original line number Original line Diff line number Diff line
@@ -435,8 +435,8 @@ std::optional<Request> ExecutionContext::createRequest(const TestModel& testMode 
        mInputMemory = TestBlobAHWB::create(std::max<size_t>(inputSize, 1));

        mInputMemory = TestBlobAHWB::create(std::max<size_t>(inputSize, 1));

        mOutputMemory = TestBlobAHWB::create(std::max<size_t>(outputSize, 1));

        mOutputMemory = TestBlobAHWB::create(std::max<size_t>(outputSize, 1));

    } else {

    } else {

        mInputMemory = TestAshmem::create(std::max<size_t>(inputSize, 1));

        mInputMemory = TestAshmem::create(std::max<size_t>(inputSize, 1), /*aidlReadonly=*/true);

        mOutputMemory = TestAshmem::create(std::max<size_t>(outputSize, 1));

        mOutputMemory = TestAshmem::create(std::max<size_t>(outputSize, 1), /*aidlReadonly=*/false);

    }

    }

    CHECK_NE(mInputMemory, nullptr);

    CHECK_NE(mInputMemory, nullptr);

    CHECK_NE(mOutputMemory, nullptr);

    CHECK_NE(mOutputMemory, nullptr);

neuralnetworks/aidl/vts/functional/Utils.cpp

+25 −4
Original line number Original line Diff line number Diff line
@@ -23,6 +23,7 @@ 
#include <android/binder_status.h>

#include <android/binder_status.h>

#include <android/hardware_buffer.h>

#include <android/hardware_buffer.h>





#include <sys/mman.h>

#include <iostream>

#include <iostream>

#include <limits>

#include <limits>

#include <numeric>

#include <numeric>
@@ -98,19 +99,39 @@ uint32_t sizeOfData(const Operand& operand) { 
                           std::multiplies<>{});

                           std::multiplies<>{});

}

}





std::unique_ptr<TestAshmem> TestAshmem::create(uint32_t size) {

std::unique_ptr<TestAshmem> TestAshmem::create(uint32_t size, bool aidlReadonly) {

    auto ashmem = std::make_unique<TestAshmem>(size);

    auto ashmem = std::make_unique<TestAshmem>(size, aidlReadonly);

    return ashmem->mIsValid ? std::move(ashmem) : nullptr;

    return ashmem->mIsValid ? std::move(ashmem) : nullptr;

}

}





void TestAshmem::initialize(uint32_t size) {

// This function will create a readonly shared memory with PROT_READ only.

// The input shared memory must be either Ashmem or mapped-FD.

static nn::SharedMemory convertSharedMemoryToReadonly(const nn::SharedMemory& sharedMemory) {

    if (std::holds_alternative<nn::Memory::Ashmem>(sharedMemory->handle)) {

        const auto& memory = std::get<nn::Memory::Ashmem>(sharedMemory->handle);

        return nn::createSharedMemoryFromFd(memory.size, PROT_READ, memory.fd.get(), /*offset=*/0)

                .value();

    } else if (std::holds_alternative<nn::Memory::Fd>(sharedMemory->handle)) {

        const auto& memory = std::get<nn::Memory::Fd>(sharedMemory->handle);

        return nn::createSharedMemoryFromFd(memory.size, PROT_READ, memory.fd.get(), memory.offset)

                .value();

    }

    CHECK(false) << "Unexpected shared memory type";

    return sharedMemory;

}



void TestAshmem::initialize(uint32_t size, bool aidlReadonly) {

    mIsValid = false;

    mIsValid = false;

    ASSERT_GT(size, 0);

    ASSERT_GT(size, 0);

    const auto sharedMemory = nn::createSharedMemory(size).value();

    const auto sharedMemory = nn::createSharedMemory(size).value();

    mMappedMemory = nn::map(sharedMemory).value();

    mMappedMemory = nn::map(sharedMemory).value();

    mPtr = static_cast<uint8_t*>(std::get<void*>(mMappedMemory.pointer));

    mPtr = static_cast<uint8_t*>(std::get<void*>(mMappedMemory.pointer));

    CHECK_NE(mPtr, nullptr);

    CHECK_NE(mPtr, nullptr);

    if (aidlReadonly) {

        mAidlMemory = utils::convert(convertSharedMemoryToReadonly(sharedMemory)).value();

    } else {

        mAidlMemory = utils::convert(sharedMemory).value();

        mAidlMemory = utils::convert(sharedMemory).value();

    }

    mIsValid = true;

    mIsValid = true;

}

}

neuralnetworks/aidl/vts/functional/Utils.h

+6 −3
Original line number Original line Diff line number Diff line
@@ -79,15 +79,18 @@ class TestMemoryBase { 




class TestAshmem : public TestMemoryBase {

class TestAshmem : public TestMemoryBase {

  public:

  public:

    static std::unique_ptr<TestAshmem> create(uint32_t size);

    // If aidlReadonly is true, getAidlMemory will return a sAIDL memory with readonly access;

    // otherwise, the sAIDL memory has read-write access. This only affects the sAIDL memory.

    // getPointer will always return a valid address with read-write access.

    static std::unique_ptr<TestAshmem> create(uint32_t size, bool aidlReadonly = false);





    // Prefer TestAshmem::create.

    // Prefer TestAshmem::create.

    // The constructor calls initialize, which constructs the memory resources. This is a workaround

    // The constructor calls initialize, which constructs the memory resources. This is a workaround

    // that gtest macros cannot be used directly in a constructor.

    // that gtest macros cannot be used directly in a constructor.

    TestAshmem(uint32_t size) { initialize(size); }

    TestAshmem(uint32_t size, bool aidlReadonly) { initialize(size, aidlReadonly); }





  private:

  private:

    void initialize(uint32_t size);

    void initialize(uint32_t size, bool aidlReadonly);

    nn::Mapping mMappedMemory;

    nn::Mapping mMappedMemory;

};

};