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

Commit 12ec862f authored by Michael Butler's avatar Michael Butler Committed by Gerrit Code Review
Browse files

Merge "Simplify NNAPI SharedHandle -- hal"

parents 1e6730ac e52a77ef

neuralnetworks/1.3/utils/src/Conversions.cpp

+1 −1
Original line number Diff line number Diff line
@@ -239,7 +239,7 @@ GeneralResult<Request::MemoryPool> unvalidatedConvert( 
    using Discriminator = hal::V1_3::Request::MemoryPool::hidl_discriminator;

    switch (memoryPool.getDiscriminator()) {

        case Discriminator::hidlMemory:

            return hal::utils::createSharedMemoryFromHidlMemory(memoryPool.hidlMemory());

            return unvalidatedConvert(memoryPool.hidlMemory());

        case Discriminator::token:

            return static_cast<Request::MemoryDomainToken>(memoryPool.token());

    }

neuralnetworks/aidl/utils/include/nnapi/hal/aidl/Conversions.h

+3 −7
Original line number Diff line number Diff line
@@ -95,9 +95,7 @@ GeneralResult<ExecutionPreference> unvalidatedConvert( 
GeneralResult<Extension> unvalidatedConvert(const aidl_hal::Extension& extension);

GeneralResult<Extension::OperandTypeInformation> unvalidatedConvert(

        const aidl_hal::ExtensionOperandTypeInformation& operandTypeInformation);

GeneralResult<SharedHandle> unvalidatedConvert(

        const ::aidl::android::hardware::common::NativeHandle& handle);

GeneralResult<SyncFence> unvalidatedConvert(const ndk::ScopedFileDescriptor& syncFence);

GeneralResult<SharedHandle> unvalidatedConvert(const ndk::ScopedFileDescriptor& handle);



GeneralResult<std::vector<Operation>> unvalidatedConvert(

        const std::vector<aidl_hal::Operation>& operations);
@@ -113,7 +111,7 @@ GeneralResult<OperandType> convert(const aidl_hal::OperandType& operandType); 
GeneralResult<Priority> convert(const aidl_hal::Priority& priority);

GeneralResult<Request> convert(const aidl_hal::Request& request);

GeneralResult<Timing> convert(const aidl_hal::Timing& timing);

GeneralResult<SyncFence> convert(const ndk::ScopedFileDescriptor& syncFence);

GeneralResult<SharedHandle> convert(const ndk::ScopedFileDescriptor& handle);



GeneralResult<std::vector<Extension>> convert(const std::vector<aidl_hal::Extension>& extension);

GeneralResult<std::vector<SharedMemory>> convert(const std::vector<aidl_hal::Memory>& memories);
@@ -160,9 +158,7 @@ nn::GeneralResult<int64_t> unvalidatedConvert(const nn::Duration& duration); 
nn::GeneralResult<int64_t> unvalidatedConvert(const nn::OptionalDuration& optionalDuration);

nn::GeneralResult<int64_t> unvalidatedConvert(const nn::OptionalTimePoint& optionalTimePoint);

nn::GeneralResult<ndk::ScopedFileDescriptor> unvalidatedConvert(const nn::SyncFence& syncFence);

nn::GeneralResult<common::NativeHandle> unvalidatedConvert(const nn::SharedHandle& sharedHandle);

nn::GeneralResult<ndk::ScopedFileDescriptor> unvalidatedConvertCache(

        const nn::SharedHandle& handle);

nn::GeneralResult<ndk::ScopedFileDescriptor> unvalidatedConvert(const nn::SharedHandle& handle);



nn::GeneralResult<std::vector<uint8_t>> convert(const nn::CacheToken& cacheToken);

nn::GeneralResult<BufferDesc> convert(const nn::BufferDesc& bufferDesc);

neuralnetworks/aidl/utils/src/Conversions.cpp

+8 −56
Original line number Diff line number Diff line
@@ -108,17 +108,6 @@ GeneralResult<std::vector<UnvalidatedConvertOutput<Type>>> validatedConvert( 
    return canonical;

}



GeneralResult<Handle> unvalidatedConvertHelper(const NativeHandle& aidlNativeHandle) {

    std::vector<base::unique_fd> fds;

    fds.reserve(aidlNativeHandle.fds.size());

    for (const auto& fd : aidlNativeHandle.fds) {

        auto duplicatedFd = NN_TRY(dupFd(fd.get()));

        fds.emplace_back(duplicatedFd.release());

    }



    return Handle{.fds = std::move(fds), .ints = aidlNativeHandle.ints};

}



struct NativeHandleDeleter {

    void operator()(native_handle_t* handle) const {

        if (handle) {
@@ -498,18 +487,14 @@ GeneralResult<ExecutionPreference> unvalidatedConvert( 
    return static_cast<ExecutionPreference>(executionPreference);

}



GeneralResult<SharedHandle> unvalidatedConvert(const NativeHandle& aidlNativeHandle) {

    return std::make_shared<const Handle>(NN_TRY(unvalidatedConvertHelper(aidlNativeHandle)));

}



GeneralResult<std::vector<Operation>> unvalidatedConvert(

        const std::vector<aidl_hal::Operation>& operations) {

    return unvalidatedConvertVec(operations);

}



GeneralResult<SyncFence> unvalidatedConvert(const ndk::ScopedFileDescriptor& syncFence) {

    auto duplicatedFd = NN_TRY(dupFd(syncFence.get()));

    return SyncFence::create(std::move(duplicatedFd));

GeneralResult<SharedHandle> unvalidatedConvert(const ndk::ScopedFileDescriptor& handle) {

    auto duplicatedFd = NN_TRY(dupFd(handle.get()));

    return std::make_shared<const Handle>(std::move(duplicatedFd));

}



GeneralResult<Capabilities> convert(const aidl_hal::Capabilities& capabilities) {
@@ -553,8 +538,8 @@ GeneralResult<Timing> convert(const aidl_hal::Timing& timing) { 
    return validatedConvert(timing);

}



GeneralResult<SyncFence> convert(const ndk::ScopedFileDescriptor& syncFence) {

    return validatedConvert(syncFence);

GeneralResult<SharedHandle> convert(const ndk::ScopedFileDescriptor& handle) {

    return validatedConvert(handle);

}



GeneralResult<std::vector<Extension>> convert(const std::vector<aidl_hal::Extension>& extension) {
@@ -619,17 +604,6 @@ nn::GeneralResult<std::vector<UnvalidatedConvertOutput<Type>>> validatedConvert( 
    return halObject;

}



nn::GeneralResult<common::NativeHandle> unvalidatedConvert(const nn::Handle& handle) {

    common::NativeHandle aidlNativeHandle;

    aidlNativeHandle.fds.reserve(handle.fds.size());

    for (const auto& fd : handle.fds) {

        auto duplicatedFd = NN_TRY(nn::dupFd(fd.get()));

        aidlNativeHandle.fds.emplace_back(duplicatedFd.release());

    }

    aidlNativeHandle.ints = handle.ints;

    return aidlNativeHandle;

}



// Helper template for std::visit

template <class... Ts>

struct overloaded : Ts... {
@@ -755,11 +729,6 @@ nn::GeneralResult<bool> unvalidatedConvert(const nn::MeasureTiming& measureTimin 
    return measureTiming == nn::MeasureTiming::YES;

}



nn::GeneralResult<common::NativeHandle> unvalidatedConvert(const nn::SharedHandle& sharedHandle) {

    CHECK(sharedHandle != nullptr);

    return unvalidatedConvert(*sharedHandle);

}



nn::GeneralResult<Memory> unvalidatedConvert(const nn::SharedMemory& memory) {

    if (memory == nullptr) {

        return (NN_ERROR() << "Unable to convert nullptr memory")
@@ -997,16 +966,8 @@ nn::GeneralResult<ndk::ScopedFileDescriptor> unvalidatedConvert(const nn::SyncFe 
    return ndk::ScopedFileDescriptor(duplicatedFd.release());

}



nn::GeneralResult<ndk::ScopedFileDescriptor> unvalidatedConvertCache(

        const nn::SharedHandle& handle) {

    if (handle->ints.size() != 0) {

        NN_ERROR() << "Cache handle must not contain ints";

    }

    if (handle->fds.size() != 1) {

        NN_ERROR() << "Cache handle must contain exactly one fd but contains "

                   << handle->fds.size();

    }

    auto duplicatedFd = NN_TRY(nn::dupFd(handle->fds.front().get()));

nn::GeneralResult<ndk::ScopedFileDescriptor> unvalidatedConvert(const nn::SharedHandle& handle) {

    auto duplicatedFd = NN_TRY(nn::dupFd(handle->get()));

    return ndk::ScopedFileDescriptor(duplicatedFd.release());

}
@@ -1069,16 +1030,7 @@ nn::GeneralResult<std::vector<OutputShape>> convert( 


nn::GeneralResult<std::vector<ndk::ScopedFileDescriptor>> convert(

        const std::vector<nn::SharedHandle>& cacheHandles) {

    const auto version = NN_TRY(hal::utils::makeGeneralFailure(nn::validate(cacheHandles)));

    if (version > kVersion) {

        return NN_ERROR() << "Insufficient version: " << version << " vs required " << kVersion;

    }

    std::vector<ndk::ScopedFileDescriptor> cacheFds;

    cacheFds.reserve(cacheHandles.size());

    for (const auto& cacheHandle : cacheHandles) {

        cacheFds.push_back(NN_TRY(unvalidatedConvertCache(cacheHandle)));

    }

    return cacheFds;

    return validatedConvert(cacheHandles);

}



nn::GeneralResult<std::vector<ndk::ScopedFileDescriptor>> convert(

neuralnetworks/aidl/utils/src/PreparedModel.cpp

+1 −1
Original line number Diff line number Diff line
@@ -160,7 +160,7 @@ PreparedModel::executeFencedInternal(const Request& request, 


    auto resultSyncFence = nn::SyncFence::createAsSignaled();

    if (result.syncFence.get() != -1) {

        resultSyncFence = NN_TRY(nn::convert(result.syncFence));

        resultSyncFence = nn::SyncFence::create(NN_TRY(nn::convert(result.syncFence))).value();

    }



    auto callback = result.callback;

neuralnetworks/utils/common/src/CommonUtils.cpp

+43 −46
Original line number Diff line number Diff line
@@ -89,23 +89,39 @@ void copyPointersToSharedMemory(nn::Model::Subgraph* subgraph, 
                  });

}



nn::GeneralResult<hidl_handle> createNativeHandleFrom(base::unique_fd fd,

nn::GeneralResult<hidl_handle> createNativeHandleFrom(std::vector<base::unique_fd> fds,

                                                      const std::vector<int32_t>& ints) {

    constexpr size_t kIntMax = std::numeric_limits<int>::max();

    CHECK_LE(fds.size(), kIntMax);

    CHECK_LE(ints.size(), kIntMax);

    native_handle_t* nativeHandle = native_handle_create(1, static_cast<int>(ints.size()));

    native_handle_t* nativeHandle =

            native_handle_create(static_cast<int>(fds.size()), static_cast<int>(ints.size()));

    if (nativeHandle == nullptr) {

        return NN_ERROR() << "Failed to create native_handle";

    }



    nativeHandle->data[0] = fd.release();

    std::copy(ints.begin(), ints.end(), nativeHandle->data + 1);

    for (size_t i = 0; i < fds.size(); ++i) {

        nativeHandle->data[i] = fds[i].release();

    }

    std::copy(ints.begin(), ints.end(), nativeHandle->data + nativeHandle->numFds);



    hidl_handle handle;

    handle.setTo(nativeHandle, /*shouldOwn=*/true);

    return handle;

}



nn::GeneralResult<hidl_handle> createNativeHandleFrom(base::unique_fd fd,

                                                      const std::vector<int32_t>& ints) {

    std::vector<base::unique_fd> fds;

    fds.push_back(std::move(fd));

    return createNativeHandleFrom(std::move(fds), ints);

}



nn::GeneralResult<hidl_handle> createNativeHandleFrom(const nn::Memory::Unknown::Handle& handle) {

    std::vector<base::unique_fd> fds = NN_TRY(nn::dupFds(handle.fds.begin(), handle.fds.end()));

    return createNativeHandleFrom(std::move(fds), handle.ints);

}



nn::GeneralResult<hidl_memory> createHidlMemoryFrom(const nn::Memory::Ashmem& memory) {

    auto fd = NN_TRY(nn::dupFd(memory.fd));

    auto handle = NN_TRY(createNativeHandleFrom(std::move(fd), {}));
@@ -139,7 +155,22 @@ nn::GeneralResult<hidl_memory> createHidlMemoryFrom(const nn::Memory::HardwareBu 
}



nn::GeneralResult<hidl_memory> createHidlMemoryFrom(const nn::Memory::Unknown& memory) {

    return hidl_memory(memory.name, NN_TRY(hidlHandleFromSharedHandle(memory.handle)), memory.size);

    return hidl_memory(memory.name, NN_TRY(createNativeHandleFrom(memory.handle)), memory.size);

}



nn::GeneralResult<nn::Memory::Unknown::Handle> unknownHandleFromNativeHandle(

        const native_handle_t* handle) {

    if (handle == nullptr) {

        return NN_ERROR() << "unknownHandleFromNativeHandle failed because handle is nullptr";

    }



    std::vector<base::unique_fd> fds =

            NN_TRY(nn::dupFds(handle->data + 0, handle->data + handle->numFds));



    std::vector<int> ints(handle->data + handle->numFds,

                          handle->data + handle->numFds + handle->numInts);



    return nn::Memory::Unknown::Handle{.fds = std::move(fds), .ints = std::move(ints)};

}



}  // anonymous namespace
@@ -349,7 +380,7 @@ nn::GeneralResult<nn::SharedMemory> createSharedMemoryFromHidlMemory(const hidl_ 


    if (memory.name() != "hardware_buffer_blob") {

        auto handle = nn::Memory::Unknown{

                .handle = NN_TRY(sharedHandleFromNativeHandle(memory.handle())),

                .handle = NN_TRY(unknownHandleFromNativeHandle(memory.handle())),

                .size = static_cast<size_t>(memory.size()),

                .name = memory.name(),

        };
@@ -395,53 +426,19 @@ nn::GeneralResult<nn::SharedMemory> createSharedMemoryFromHidlMemory(const hidl_ 
}



nn::GeneralResult<hidl_handle> hidlHandleFromSharedHandle(const nn::Handle& handle) {

    std::vector<base::unique_fd> fds;

    fds.reserve(handle.fds.size());

    for (const auto& fd : handle.fds) {

        const int dupFd = dup(fd);

        if (dupFd == -1) {

            return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) << "Failed to dup the fd";

        }

        fds.emplace_back(dupFd);

    }



    constexpr size_t kIntMax = std::numeric_limits<int>::max();

    CHECK_LE(handle.fds.size(), kIntMax);

    CHECK_LE(handle.ints.size(), kIntMax);

    native_handle_t* nativeHandle = native_handle_create(static_cast<int>(handle.fds.size()),

                                                         static_cast<int>(handle.ints.size()));

    if (nativeHandle == nullptr) {

        return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) << "Failed to create native_handle";

    }

    for (size_t i = 0; i < fds.size(); ++i) {

        nativeHandle->data[i] = fds[i].release();

    }

    std::copy(handle.ints.begin(), handle.ints.end(), &nativeHandle->data[nativeHandle->numFds]);



    hidl_handle hidlHandle;

    hidlHandle.setTo(nativeHandle, /*shouldOwn=*/true);

    return hidlHandle;

    base::unique_fd fd = NN_TRY(nn::dupFd(handle.get()));

    return createNativeHandleFrom(std::move(fd), {});

}



nn::GeneralResult<nn::Handle> sharedHandleFromNativeHandle(const native_handle_t* handle) {

    if (handle == nullptr) {

        return NN_ERROR() << "sharedHandleFromNativeHandle failed because handle is nullptr";

    }



    std::vector<base::unique_fd> fds;

    fds.reserve(handle->numFds);

    for (int i = 0; i < handle->numFds; ++i) {

        const int dupFd = dup(handle->data[i]);

        if (dupFd == -1) {

            return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) << "Failed to dup the fd";

        }

        fds.emplace_back(dupFd);

    if (handle->numFds != 1 || handle->numInts != 0) {

        return NN_ERROR() << "sharedHandleFromNativeHandle failed because handle does not only "

                             "hold a single fd";

    }



    std::vector<int> ints(&handle->data[handle->numFds],

                          &handle->data[handle->numFds + handle->numInts]);



    return nn::Handle{.fds = std::move(fds), .ints = std::move(ints)};

    return nn::dupFd(handle->data[0]);

}



nn::GeneralResult<hidl_vec<hidl_handle>> convertSyncFences(