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

Commit dfc013ad authored by Xusong Wang's avatar Xusong Wang
Browse files

Test readonly request input in AIDL VTS. 

This CL modifies the AIDL generated tests to use readonly memory pool
for request inputs.

Bug: 188104713
Test: VtsHalNeuralnetworksTargetTest
Change-Id: I9e62f1cdeb501bf29bcb9c56317a452c9105b272
parent d02d9f27

neuralnetworks/aidl/vts/functional/GeneratedTestHarness.cpp

+2 −2
Original line number 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));

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

    } else {

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

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

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

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

    }

    CHECK_NE(mInputMemory, nullptr);

    CHECK_NE(mOutputMemory, nullptr);

neuralnetworks/aidl/vts/functional/Utils.cpp

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

#include <android/hardware_buffer.h>



#include <sys/mman.h>

#include <iostream>

#include <limits>

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

}



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

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

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

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

    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;

    ASSERT_GT(size, 0);

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

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

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

    CHECK_NE(mPtr, nullptr);

    if (aidlReadonly) {

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

    } else {

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

    }

    mIsValid = true;

}

neuralnetworks/aidl/vts/functional/Utils.h

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


class TestAshmem : public TestMemoryBase {

  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.

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

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

    void initialize(uint32_t size);

    void initialize(uint32_t size, bool aidlReadonly);

    nn::Mapping mMappedMemory;

};