diff options
Diffstat (limited to 'neuralnetworks/1.0/utils/src/Conversions.cpp')
| -rw-r--r-- | neuralnetworks/1.0/utils/src/Conversions.cpp | 303 |
1 files changed, 274 insertions, 29 deletions
diff --git a/neuralnetworks/1.0/utils/src/Conversions.cpp b/neuralnetworks/1.0/utils/src/Conversions.cpp index c0498eb876..d98fef025d 100644 --- a/neuralnetworks/1.0/utils/src/Conversions.cpp +++ b/neuralnetworks/1.0/utils/src/Conversions.cpp @@ -37,6 +37,11 @@ #include "Utils.h" +#ifdef __ANDROID__ +#include <android/hardware_buffer.h> +#include <vndk/hardware_buffer.h> +#endif // __ANDROID__ + namespace { template <typename Type> @@ -49,6 +54,7 @@ constexpr std::underlying_type_t<Type> underlyingType(Type value) { namespace android::nn { namespace { +using hardware::hidl_handle; using hardware::hidl_memory; using hardware::hidl_vec; @@ -74,6 +80,123 @@ GeneralResult<UnvalidatedConvertOutput<Type>> validatedConvert(const Type& halOb return canonical; } +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)}; +} + +nn::GeneralResult<nn::SharedMemory> createSharedMemoryFromHidlMemory(const hidl_memory& memory) { + CHECK_LE(memory.size(), std::numeric_limits<size_t>::max()); + if (!memory.valid()) { + return NN_ERROR() << "Unable to convert invalid hidl_memory"; + } + + if (memory.name() == "ashmem") { + if (memory.handle()->numFds != 1) { + return NN_ERROR() << "Unable to convert invalid ashmem memory object with " + << memory.handle()->numFds << " numFds, but expected 1"; + } + if (memory.handle()->numInts != 0) { + return NN_ERROR() << "Unable to convert invalid ashmem memory object with " + << memory.handle()->numInts << " numInts, but expected 0"; + } + auto fd = NN_TRY(nn::dupFd(memory.handle()->data[0])); + auto handle = nn::Memory::Ashmem{ + .fd = std::move(fd), + .size = static_cast<size_t>(memory.size()), + }; + return std::make_shared<const nn::Memory>(nn::Memory{.handle = std::move(handle)}); + } + + if (memory.name() == "mmap_fd") { + if (memory.handle()->numFds != 1) { + return NN_ERROR() << "Unable to convert invalid mmap_fd memory object with " + << memory.handle()->numFds << " numFds, but expected 1"; + } + if (memory.handle()->numInts != 3) { + return NN_ERROR() << "Unable to convert invalid mmap_fd memory object with " + << memory.handle()->numInts << " numInts, but expected 3"; + } + + const int fd = memory.handle()->data[0]; + const int prot = memory.handle()->data[1]; + const int lower = memory.handle()->data[2]; + const int higher = memory.handle()->data[3]; + const size_t offset = nn::getOffsetFromInts(lower, higher); + + return nn::createSharedMemoryFromFd(static_cast<size_t>(memory.size()), prot, fd, offset); + } + + if (memory.name() != "hardware_buffer_blob") { + auto handle = NN_TRY(unknownHandleFromNativeHandle(memory.handle())); + auto unknown = nn::Memory::Unknown{ + .handle = std::move(handle), + .size = static_cast<size_t>(memory.size()), + .name = memory.name(), + }; + return std::make_shared<const nn::Memory>(nn::Memory{.handle = std::move(unknown)}); + } + +#ifdef __ANDROID__ + constexpr auto roundUpToMultiple = [](uint32_t value, uint32_t multiple) -> uint32_t { + return (value + multiple - 1) / multiple * multiple; + }; + + const auto size = memory.size(); + const auto format = AHARDWAREBUFFER_FORMAT_BLOB; + const auto usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN; + const uint32_t width = size; + const uint32_t height = 1; // height is always 1 for BLOB mode AHardwareBuffer. + const uint32_t layers = 1; // layers is always 1 for BLOB mode AHardwareBuffer. + + // AHardwareBuffer_createFromHandle() might fail because an allocator + // expects a specific stride value. In that case, we try to guess it by + // aligning the width to small powers of 2. + // TODO(b/174120849): Avoid stride assumptions. + AHardwareBuffer* hardwareBuffer = nullptr; + status_t status = UNKNOWN_ERROR; + for (uint32_t alignment : {1, 4, 32, 64, 128, 2, 8, 16}) { + const uint32_t stride = roundUpToMultiple(width, alignment); + AHardwareBuffer_Desc desc{ + .width = width, + .height = height, + .layers = layers, + .format = format, + .usage = usage, + .stride = stride, + }; + status = AHardwareBuffer_createFromHandle(&desc, memory.handle(), + AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE, + &hardwareBuffer); + if (status == NO_ERROR) { + break; + } + } + if (status != NO_ERROR) { + return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) + << "Can't create AHardwareBuffer from handle. Error: " << status; + } + + return nn::createSharedMemoryFromAHWB(hardwareBuffer, /*takeOwnership=*/true); +#else // __ANDROID__ + LOG(FATAL) << "nn::GeneralResult<nn::SharedMemory> createSharedMemoryFromHidlMemory(const " + "hidl_memory& memory): Not Available on Host Build"; + return (NN_ERROR() << "createSharedMemoryFromHidlMemory failed") + . + operator nn::GeneralResult<nn::SharedMemory>(); +#endif // __ANDROID__ +} + } // anonymous namespace GeneralResult<OperandType> unvalidatedConvert(const hal::V1_0::OperandType& operandType) { @@ -124,19 +247,23 @@ GeneralResult<DataLocation> unvalidatedConvert(const hal::V1_0::DataLocation& lo } GeneralResult<Operand> unvalidatedConvert(const hal::V1_0::Operand& operand) { + const auto type = NN_TRY(unvalidatedConvert(operand.type)); + const auto lifetime = NN_TRY(unvalidatedConvert(operand.lifetime)); + const auto location = NN_TRY(unvalidatedConvert(operand.location)); return Operand{ - .type = NN_TRY(unvalidatedConvert(operand.type)), + .type = type, .dimensions = operand.dimensions, .scale = operand.scale, .zeroPoint = operand.zeroPoint, - .lifetime = NN_TRY(unvalidatedConvert(operand.lifetime)), - .location = NN_TRY(unvalidatedConvert(operand.location)), + .lifetime = lifetime, + .location = location, }; } GeneralResult<Operation> unvalidatedConvert(const hal::V1_0::Operation& operation) { + const auto type = NN_TRY(unvalidatedConvert(operation.type)); return Operation{ - .type = NN_TRY(unvalidatedConvert(operation.type)), + .type = type, .inputs = operation.inputs, .outputs = operation.outputs, }; @@ -146,8 +273,20 @@ GeneralResult<Model::OperandValues> unvalidatedConvert(const hidl_vec<uint8_t>& return Model::OperandValues(operandValues.data(), operandValues.size()); } +GeneralResult<SharedHandle> unvalidatedConvert(const hidl_handle& handle) { + if (handle.getNativeHandle() == nullptr) { + return nullptr; + } + if (handle->numFds != 1 || handle->numInts != 0) { + return NN_ERROR() + << "unvalidatedConvert failed because handle does not only hold a single fd"; + } + auto duplicatedFd = NN_TRY(nn::dupFd(handle->data[0])); + return std::make_shared<const Handle>(std::move(duplicatedFd)); +} + GeneralResult<SharedMemory> unvalidatedConvert(const hidl_memory& memory) { - return hal::utils::createSharedMemoryFromHidlMemory(memory); + return createSharedMemoryFromHidlMemory(memory); } GeneralResult<Model> unvalidatedConvert(const hal::V1_0::Model& model) { @@ -155,7 +294,7 @@ GeneralResult<Model> unvalidatedConvert(const hal::V1_0::Model& model) { // Verify number of consumers. const auto numberOfConsumers = - NN_TRY(hal::utils::countNumberOfConsumers(model.operands.size(), operations)); + NN_TRY(countNumberOfConsumers(model.operands.size(), operations)); CHECK(model.operands.size() == numberOfConsumers.size()); for (size_t i = 0; i < model.operands.size(); ++i) { if (model.operands[i].numberOfConsumers != numberOfConsumers[i]) { @@ -165,26 +304,30 @@ GeneralResult<Model> unvalidatedConvert(const hal::V1_0::Model& model) { } } + auto operands = NN_TRY(unvalidatedConvert(model.operands)); auto main = Model::Subgraph{ - .operands = NN_TRY(unvalidatedConvert(model.operands)), + .operands = std::move(operands), .operations = std::move(operations), .inputIndexes = model.inputIndexes, .outputIndexes = model.outputIndexes, }; + auto operandValues = NN_TRY(unvalidatedConvert(model.operandValues)); + auto pools = NN_TRY(unvalidatedConvert(model.pools)); return Model{ .main = std::move(main), - .operandValues = NN_TRY(unvalidatedConvert(model.operandValues)), - .pools = NN_TRY(unvalidatedConvert(model.pools)), + .operandValues = std::move(operandValues), + .pools = std::move(pools), }; } GeneralResult<Request::Argument> unvalidatedConvert(const hal::V1_0::RequestArgument& argument) { const auto lifetime = argument.hasNoValue ? Request::Argument::LifeTime::NO_VALUE : Request::Argument::LifeTime::POOL; + const auto location = NN_TRY(unvalidatedConvert(argument.location)); return Request::Argument{ .lifetime = lifetime, - .location = NN_TRY(unvalidatedConvert(argument.location)), + .location = location, .dimensions = argument.dimensions, }; } @@ -195,9 +338,11 @@ GeneralResult<Request> unvalidatedConvert(const hal::V1_0::Request& request) { pools.reserve(memories.size()); std::move(memories.begin(), memories.end(), std::back_inserter(pools)); + auto inputs = NN_TRY(unvalidatedConvert(request.inputs)); + auto outputs = NN_TRY(unvalidatedConvert(request.outputs)); return Request{ - .inputs = NN_TRY(unvalidatedConvert(request.inputs)), - .outputs = NN_TRY(unvalidatedConvert(request.outputs)), + .inputs = std::move(inputs), + .outputs = std::move(outputs), .pools = std::move(pools), }; } @@ -260,6 +405,82 @@ nn::GeneralResult<UnvalidatedConvertOutput<Type>> validatedConvert(const Type& c return utils::unvalidatedConvert(canonical); } +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(static_cast<int>(fds.size()), static_cast<int>(ints.size())); + if (nativeHandle == nullptr) { + return NN_ERROR() << "Failed to create native_handle"; + } + + 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), {})); + return hidl_memory("ashmem", std::move(handle), memory.size); +} + +nn::GeneralResult<hidl_memory> createHidlMemoryFrom(const nn::Memory::Fd& memory) { + auto fd = NN_TRY(nn::dupFd(memory.fd)); + + const auto [lowOffsetBits, highOffsetBits] = nn::getIntsFromOffset(memory.offset); + const std::vector<int> ints = {memory.prot, lowOffsetBits, highOffsetBits}; + + auto handle = NN_TRY(createNativeHandleFrom(std::move(fd), ints)); + return hidl_memory("mmap_fd", std::move(handle), memory.size); +} + +nn::GeneralResult<hidl_memory> createHidlMemoryFrom(const nn::Memory::HardwareBuffer& memory) { +#ifdef __ANDROID__ + const auto* ahwb = memory.handle.get(); + AHardwareBuffer_Desc bufferDesc; + AHardwareBuffer_describe(ahwb, &bufferDesc); + + const bool isBlob = bufferDesc.format == AHARDWAREBUFFER_FORMAT_BLOB; + const size_t size = isBlob ? bufferDesc.width : 0; + const char* const name = isBlob ? "hardware_buffer_blob" : "hardware_buffer"; + + const native_handle_t* nativeHandle = AHardwareBuffer_getNativeHandle(ahwb); + const hidl_handle hidlHandle(nativeHandle); + hidl_handle copiedHandle(hidlHandle); + + return hidl_memory(name, std::move(copiedHandle), size); +#else // __ANDROID__ + LOG(FATAL) << "nn::GeneralResult<hidl_memory> createHidlMemoryFrom(const " + "nn::Memory::HardwareBuffer& memory): Not Available on Host Build"; + (void)memory; + return (NN_ERROR() << "createHidlMemoryFrom failed").operator nn::GeneralResult<hidl_memory>(); +#endif // __ANDROID__ +} + +nn::GeneralResult<hidl_memory> createHidlMemoryFrom(const nn::Memory::Unknown& memory) { + return hidl_memory(memory.name, NN_TRY(createNativeHandleFrom(memory.handle)), memory.size); +} + } // anonymous namespace nn::GeneralResult<OperandType> unvalidatedConvert(const nn::OperandType& operandType) { @@ -291,11 +512,13 @@ nn::GeneralResult<PerformanceInfo> unvalidatedConvert( } nn::GeneralResult<Capabilities> unvalidatedConvert(const nn::Capabilities& capabilities) { + const auto float32Performance = NN_TRY(unvalidatedConvert( + capabilities.operandPerformance.lookup(nn::OperandType::TENSOR_FLOAT32))); + const auto quantized8Performance = NN_TRY(unvalidatedConvert( + capabilities.operandPerformance.lookup(nn::OperandType::TENSOR_QUANT8_ASYMM))); return Capabilities{ - .float32Performance = NN_TRY(unvalidatedConvert( - capabilities.operandPerformance.lookup(nn::OperandType::TENSOR_FLOAT32))), - .quantized8Performance = NN_TRY(unvalidatedConvert( - capabilities.operandPerformance.lookup(nn::OperandType::TENSOR_QUANT8_ASYMM))), + .float32Performance = float32Performance, + .quantized8Performance = quantized8Performance, }; } @@ -308,20 +531,24 @@ nn::GeneralResult<DataLocation> unvalidatedConvert(const nn::DataLocation& locat } nn::GeneralResult<Operand> unvalidatedConvert(const nn::Operand& operand) { + const auto type = NN_TRY(unvalidatedConvert(operand.type)); + const auto lifetime = NN_TRY(unvalidatedConvert(operand.lifetime)); + const auto location = NN_TRY(unvalidatedConvert(operand.location)); return Operand{ - .type = NN_TRY(unvalidatedConvert(operand.type)), + .type = type, .dimensions = operand.dimensions, .numberOfConsumers = 0, .scale = operand.scale, .zeroPoint = operand.zeroPoint, - .lifetime = NN_TRY(unvalidatedConvert(operand.lifetime)), - .location = NN_TRY(unvalidatedConvert(operand.location)), + .lifetime = lifetime, + .location = location, }; } nn::GeneralResult<Operation> unvalidatedConvert(const nn::Operation& operation) { + const auto type = NN_TRY(unvalidatedConvert(operation.type)); return Operation{ - .type = NN_TRY(unvalidatedConvert(operation.type)), + .type = type, .inputs = operation.inputs, .outputs = operation.outputs, }; @@ -332,8 +559,19 @@ nn::GeneralResult<hidl_vec<uint8_t>> unvalidatedConvert( return hidl_vec<uint8_t>(operandValues.data(), operandValues.data() + operandValues.size()); } +nn::GeneralResult<hidl_handle> unvalidatedConvert(const nn::SharedHandle& handle) { + if (handle == nullptr) { + return {}; + } + base::unique_fd fd = NN_TRY(nn::dupFd(handle->get())); + return createNativeHandleFrom(std::move(fd), {}); +} + nn::GeneralResult<hidl_memory> unvalidatedConvert(const nn::SharedMemory& memory) { - return hal::utils::createHidlMemoryFromSharedMemory(memory); + if (memory == nullptr) { + return NN_ERROR() << "Memory must be non-empty"; + } + return std::visit([](const auto& x) { return createHidlMemoryFrom(x); }, memory->handle); } nn::GeneralResult<Model> unvalidatedConvert(const nn::Model& model) { @@ -346,19 +584,22 @@ nn::GeneralResult<Model> unvalidatedConvert(const nn::Model& model) { // Update number of consumers. const auto numberOfConsumers = - NN_TRY(hal::utils::countNumberOfConsumers(operands.size(), model.main.operations)); + NN_TRY(countNumberOfConsumers(operands.size(), model.main.operations)); CHECK(operands.size() == numberOfConsumers.size()); for (size_t i = 0; i < operands.size(); ++i) { operands[i].numberOfConsumers = numberOfConsumers[i]; } + auto operations = NN_TRY(unvalidatedConvert(model.main.operations)); + auto operandValues = NN_TRY(unvalidatedConvert(model.operandValues)); + auto pools = NN_TRY(unvalidatedConvert(model.pools)); return Model{ .operands = std::move(operands), - .operations = NN_TRY(unvalidatedConvert(model.main.operations)), + .operations = std::move(operations), .inputIndexes = model.main.inputIndexes, .outputIndexes = model.main.outputIndexes, - .operandValues = NN_TRY(unvalidatedConvert(model.operandValues)), - .pools = NN_TRY(unvalidatedConvert(model.pools)), + .operandValues = std::move(operandValues), + .pools = std::move(pools), }; } @@ -369,9 +610,10 @@ nn::GeneralResult<RequestArgument> unvalidatedConvert( << "Request cannot be unvalidatedConverted because it contains pointer-based memory"; } const bool hasNoValue = requestArgument.lifetime == nn::Request::Argument::LifeTime::NO_VALUE; + const auto location = NN_TRY(unvalidatedConvert(requestArgument.location)); return RequestArgument{ .hasNoValue = hasNoValue, - .location = NN_TRY(unvalidatedConvert(requestArgument.location)), + .location = location, .dimensions = requestArgument.dimensions, }; } @@ -386,10 +628,13 @@ nn::GeneralResult<Request> unvalidatedConvert(const nn::Request& request) { << "Request cannot be unvalidatedConverted because it contains pointer-based memory"; } + auto inputs = NN_TRY(unvalidatedConvert(request.inputs)); + auto outputs = NN_TRY(unvalidatedConvert(request.outputs)); + auto pools = NN_TRY(unvalidatedConvert(request.pools)); return Request{ - .inputs = NN_TRY(unvalidatedConvert(request.inputs)), - .outputs = NN_TRY(unvalidatedConvert(request.outputs)), - .pools = NN_TRY(unvalidatedConvert(request.pools)), + .inputs = std::move(inputs), + .outputs = std::move(outputs), + .pools = std::move(pools), }; } |