From 534556391ae153b1e8fdd11b233e2dc6ecd1e530 Mon Sep 17 00:00:00 2001 From: Michael Butler Date: Mon, 25 Oct 2021 11:20:33 -0700 Subject: Create NN AIDL adapter This change adds the following adapters: * nn::IDevice -> BnDevice * nn::IPreparedModel -> BnPreparedModel * nn::IBurst -> BnBurst * nn::IBuffer -> BnBuffer Bug: N/A Test: mma Test: locally created a binderized service with this adapter code, which passed VtsHalNeuralnetworksTargetTest Change-Id: I966f65a1e4d75284c050b77f3f40c515e4970130 --- neuralnetworks/aidl/utils/src/Conversions.cpp | 173 +++++++++++++++++++------- 1 file changed, 128 insertions(+), 45 deletions(-) (limited to 'neuralnetworks/aidl/utils/src/Conversions.cpp') diff --git a/neuralnetworks/aidl/utils/src/Conversions.cpp b/neuralnetworks/aidl/utils/src/Conversions.cpp index 45628c8e73..113d2da955 100644 --- a/neuralnetworks/aidl/utils/src/Conversions.cpp +++ b/neuralnetworks/aidl/utils/src/Conversions.cpp @@ -551,6 +551,10 @@ GeneralResult convert(const ndk::ScopedFileDescriptor& handle) { return validatedConvert(handle); } +GeneralResult convert(const aidl_hal::BufferDesc& bufferDesc) { + return validatedConvert(bufferDesc); +} + GeneralResult> convert(const std::vector& extension) { return validatedConvert(extension); } @@ -564,6 +568,15 @@ GeneralResult> convert( return validatedConvert(outputShapes); } +GeneralResult> convert( + const std::vector& handles) { + return validatedConvert(handles); +} + +GeneralResult> convert(const std::vector& roles) { + return validatedConvert(roles); +} + GeneralResult> toUnsigned(const std::vector& vec) { if (!std::all_of(vec.begin(), vec.end(), [](int32_t v) { return v >= 0; })) { return NN_ERROR() << "Negative value passed to conversion from signed to unsigned"; @@ -576,42 +589,7 @@ GeneralResult> toUnsigned(const std::vector& vec) namespace aidl::android::hardware::neuralnetworks::utils { namespace { -template -using UnvalidatedConvertOutput = - std::decay_t()).value())>; - -template -nn::GeneralResult>> unvalidatedConvertVec( - const std::vector& arguments) { - std::vector> halObject; - halObject.reserve(arguments.size()); - for (const auto& argument : arguments) { - halObject.push_back(NN_TRY(unvalidatedConvert(argument))); - } - return halObject; -} - -template -nn::GeneralResult>> unvalidatedConvert( - const std::vector& arguments) { - return unvalidatedConvertVec(arguments); -} - -template -nn::GeneralResult> validatedConvert(const Type& canonical) { - NN_TRY(compliantVersion(canonical)); - return utils::unvalidatedConvert(canonical); -} - -template -nn::GeneralResult>> validatedConvert( - const std::vector& arguments) { - std::vector> halObject(arguments.size()); - for (size_t i = 0; i < arguments.size(); ++i) { - halObject[i] = NN_TRY(validatedConvert(arguments[i])); - } - return halObject; -} +using utils::unvalidatedConvert; // Helper template for std::visit template @@ -721,6 +699,74 @@ nn::GeneralResult unvalidatedConvert(const nn::Memory::Unknown& /*memory operator nn::GeneralResult(); } +nn::GeneralResult unvalidatedConvert( + const nn::Capabilities::PerformanceInfo& info) { + return PerformanceInfo{.execTime = info.execTime, .powerUsage = info.powerUsage}; +} + +nn::GeneralResult unvalidatedConvert( + const nn::Capabilities::OperandPerformance& operandPerformance) { + return OperandPerformance{.type = NN_TRY(unvalidatedConvert(operandPerformance.type)), + .info = NN_TRY(unvalidatedConvert(operandPerformance.info))}; +} + +nn::GeneralResult> unvalidatedConvert( + const nn::Capabilities::OperandPerformanceTable& table) { + std::vector operandPerformances; + operandPerformances.reserve(table.asVector().size()); + for (const auto& operandPerformance : table.asVector()) { + operandPerformances.push_back(NN_TRY(unvalidatedConvert(operandPerformance))); + } + return operandPerformances; +} + +nn::GeneralResult unvalidatedConvert( + const nn::Extension::OperandTypeInformation& info) { + return ExtensionOperandTypeInformation{.type = info.type, + .isTensor = info.isTensor, + .byteSize = static_cast(info.byteSize)}; +} + +nn::GeneralResult unvalidatedConvert(const nn::Duration& duration) { + if (duration < nn::Duration::zero()) { + return NN_ERROR() << "Unable to convert invalid (negative) duration"; + } + constexpr std::chrono::nanoseconds::rep kIntMax = std::numeric_limits::max(); + const auto count = duration.count(); + return static_cast(std::min(count, kIntMax)); +} + +template +using UnvalidatedConvertOutput = + std::decay_t()).value())>; + +template +nn::GeneralResult>> unvalidatedConvert( + const std::vector& arguments) { + std::vector> halObject; + halObject.reserve(arguments.size()); + for (const auto& argument : arguments) { + halObject.push_back(NN_TRY(unvalidatedConvert(argument))); + } + return halObject; +} + +template +nn::GeneralResult> validatedConvert(const Type& canonical) { + NN_TRY(compliantVersion(canonical)); + return utils::unvalidatedConvert(canonical); +} + +template +nn::GeneralResult>> validatedConvert( + const std::vector& arguments) { + std::vector> halObject(arguments.size()); + for (size_t i = 0; i < arguments.size(); ++i) { + halObject[i] = NN_TRY(validatedConvert(arguments[i])); + } + return halObject; +} + } // namespace nn::GeneralResult> unvalidatedConvert(const nn::CacheToken& cacheToken) { @@ -743,6 +789,19 @@ nn::GeneralResult unvalidatedConvert(const nn::BufferRole& bufferRol }; } +nn::GeneralResult unvalidatedConvert(const nn::DeviceType& deviceType) { + switch (deviceType) { + case nn::DeviceType::UNKNOWN: + break; + case nn::DeviceType::OTHER: + case nn::DeviceType::CPU: + case nn::DeviceType::GPU: + case nn::DeviceType::ACCELERATOR: + return static_cast(deviceType); + } + return NN_ERROR() << "Invalid DeviceType " << deviceType; +} + nn::GeneralResult unvalidatedConvert(const nn::MeasureTiming& measureTiming) { return measureTiming == nn::MeasureTiming::YES; } @@ -956,15 +1015,6 @@ nn::GeneralResult unvalidatedConvert(const nn::Timing& timing) { }; } -nn::GeneralResult unvalidatedConvert(const nn::Duration& duration) { - if (duration < nn::Duration::zero()) { - return NN_ERROR() << "Unable to convert invalid (negative) duration"; - } - constexpr std::chrono::nanoseconds::rep kIntMax = std::numeric_limits::max(); - const auto count = duration.count(); - return static_cast(std::min(count, kIntMax)); -} - nn::GeneralResult unvalidatedConvert(const nn::OptionalDuration& optionalDuration) { if (!optionalDuration.has_value()) { return kNoTiming; @@ -989,6 +1039,23 @@ nn::GeneralResult unvalidatedConvert(const nn::Shared return ndk::ScopedFileDescriptor(duplicatedFd.release()); } +nn::GeneralResult unvalidatedConvert(const nn::Capabilities& capabilities) { + return Capabilities{ + .relaxedFloat32toFloat16PerformanceTensor = NN_TRY( + unvalidatedConvert(capabilities.relaxedFloat32toFloat16PerformanceTensor)), + .relaxedFloat32toFloat16PerformanceScalar = NN_TRY( + unvalidatedConvert(capabilities.relaxedFloat32toFloat16PerformanceScalar)), + .operandPerformance = NN_TRY(unvalidatedConvert(capabilities.operandPerformance)), + .ifPerformance = NN_TRY(unvalidatedConvert(capabilities.ifPerformance)), + .whilePerformance = NN_TRY(unvalidatedConvert(capabilities.whilePerformance)), + }; +} + +nn::GeneralResult unvalidatedConvert(const nn::Extension& extension) { + return Extension{.name = extension.name, + .operandTypes = NN_TRY(unvalidatedConvert(extension.operandTypes))}; +} + nn::GeneralResult> convert(const nn::CacheToken& cacheToken) { return validatedConvert(cacheToken); } @@ -997,6 +1064,10 @@ nn::GeneralResult convert(const nn::BufferDesc& bufferDesc) { return validatedConvert(bufferDesc); } +nn::GeneralResult convert(const nn::DeviceType& deviceType) { + return validatedConvert(deviceType); +} + nn::GeneralResult convert(const nn::MeasureTiming& measureTiming) { return validatedConvert(measureTiming); } @@ -1037,6 +1108,14 @@ nn::GeneralResult convert(const nn::OptionalTimePoint& outputShapes) { return validatedConvert(outputShapes); } +nn::GeneralResult convert(const nn::Capabilities& capabilities) { + return validatedConvert(capabilities); +} + +nn::GeneralResult convert(const nn::Extension& extension) { + return validatedConvert(extension); +} + nn::GeneralResult> convert(const std::vector& bufferRoles) { return validatedConvert(bufferRoles); } @@ -1056,6 +1135,10 @@ nn::GeneralResult> convert( return validatedConvert(syncFences); } +nn::GeneralResult> convert(const std::vector& extensions) { + return validatedConvert(extensions); +} + nn::GeneralResult> toSigned(const std::vector& vec) { if (!std::all_of(vec.begin(), vec.end(), [](uint32_t v) { return v <= std::numeric_limits::max(); })) { -- cgit v1.2.3