From f0459943892f95d93a51635f9cdaefda6f7f2894 Mon Sep 17 00:00:00 2001 From: Edward Chen <18449977+edgchen1@users.noreply.github.com> Date: Mon, 27 Jun 2022 18:54:06 -0700 Subject: [PATCH] [NNAPI EP] Update NNAPI headers (#11954) Update the NNAPI headers to a more recent version (copied from TF Lite v2.9.1). --- cmake/onnxruntime_providers.cmake | 56 ++- .../nnapi/nnapi_builtin/builders/helper.h | 2 +- .../nnapi_lib/NeuralNetworksTypes.h | 171 ++++++++- .../nnapi_lib/NeuralNetworksWrapper.cc | 2 - .../nnapi_lib/NeuralNetworksWrapper.h | 14 +- .../nnapi_lib/nnapi_implementation.cc | 263 +++++--------- .../nnapi_lib/nnapi_implementation.h | 325 +++++++++++++++++- .../nnapi_lib/nnapi_implementation_stub.cc | 245 +++++++++++++ .../nnapi/nnapi_builtin/nnapi_lib/readme.txt | 20 +- 9 files changed, 867 insertions(+), 231 deletions(-) create mode 100644 onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation_stub.cc diff --git a/cmake/onnxruntime_providers.cmake b/cmake/onnxruntime_providers.cmake index 77eac4b6a8..088952f043 100644 --- a/cmake/onnxruntime_providers.cmake +++ b/cmake/onnxruntime_providers.cmake @@ -816,7 +816,7 @@ if (onnxruntime_USE_OPENVINO) add_dependencies(onnxruntime_providers_openvino onnxruntime_providers_shared ${onnxruntime_EXTERNAL_DEPENDENCIES}) target_include_directories(onnxruntime_providers_openvino SYSTEM PUBLIC ${ONNXRUNTIME_ROOT} ${CMAKE_CURRENT_BINARY_DIR} ${eigen_INCLUDE_DIRS} ${OpenVINO_INCLUDE_DIR} ${OPENVINO_INCLUDE_DIR_LIST} ${PYTHON_INCLUDE_DIRS} $ENV{OPENCL_INCS}) target_link_libraries(onnxruntime_providers_openvino ${ONNXRUNTIME_PROVIDERS_SHARED} ${OPENVINO_LIB_LIST} ${ABSEIL_LIBS}) - + target_compile_definitions(onnxruntime_providers_openvino PRIVATE VER_MAJOR=${VERSION_MAJOR_PART}) target_compile_definitions(onnxruntime_providers_openvino PRIVATE VER_MINOR=${VERSION_MINOR_PART}) target_compile_definitions(onnxruntime_providers_openvino PRIVATE VER_BUILD=${VERSION_BUILD_PART}) @@ -978,45 +978,39 @@ if (onnxruntime_USE_NNAPI_BUILTIN) add_compile_definitions(ORT_NNAPI_MAX_SUPPORTED_API_LEVEL=${onnxruntime_NNAPI_HOST_API}) endif() - file(GLOB - onnxruntime_providers_nnapi_cc_srcs_top CONFIGURE_DEPENDS - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/*.cc" + set(onnxruntime_provider_nnapi_cc_src_patterns + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/*.h" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/*.cc" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/*.h" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/*.cc" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/builders/*.h" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/builders/*.cc" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.h" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.cc" + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.h" ) + # On Android, use the actual NNAPI implementation. + # Otherwise, use a stub implementation to support some unit testing. + if(CMAKE_SYSTEM_NAME STREQUAL "Android") + list(APPEND onnxruntime_provider_nnapi_cc_src_patterns + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.cc") + else() + list(APPEND onnxruntime_provider_nnapi_cc_src_patterns + "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation_stub.cc") + endif() + # These are shared utils, # TODO, move this to a separated lib when used by EPs other than NNAPI and CoreML - file(GLOB_RECURSE onnxruntime_providers_shared_utils_cc_srcs CONFIGURE_DEPENDS + list(APPEND onnxruntime_provider_nnapi_cc_src_patterns "${ONNXRUNTIME_ROOT}/core/providers/shared/utils/utils.h" "${ONNXRUNTIME_ROOT}/core/providers/shared/utils/utils.cc" "${ONNXRUNTIME_ROOT}/core/providers/shared/node_unit/node_unit.h" "${ONNXRUNTIME_ROOT}/core/providers/shared/node_unit/node_unit.cc" ) - if(CMAKE_SYSTEM_NAME STREQUAL "Android") - file(GLOB_RECURSE - onnxruntime_providers_nnapi_cc_srcs_nested CONFIGURE_DEPENDS - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/*.h" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/*.cc" - ) - else() - file(GLOB - onnxruntime_providers_nnapi_cc_srcs_nested CONFIGURE_DEPENDS - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/model.*" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_execution_provider.h" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_execution_provider.cc" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/builders/*.h" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/builders/*.cc" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.*" - "${ONNXRUNTIME_ROOT}/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.*" - ) - endif() - - set(onnxruntime_providers_nnapi_cc_srcs - ${onnxruntime_providers_nnapi_cc_srcs_top} - ${onnxruntime_providers_nnapi_cc_srcs_nested} - ${onnxruntime_providers_shared_utils_cc_srcs} - ) + file(GLOB onnxruntime_providers_nnapi_cc_srcs CONFIGURE_DEPENDS ${onnxruntime_provider_nnapi_cc_src_patterns}) source_group(TREE ${ONNXRUNTIME_ROOT}/core FILES ${onnxruntime_providers_nnapi_cc_srcs}) onnxruntime_add_static_library(onnxruntime_providers_nnapi ${onnxruntime_providers_nnapi_cc_srcs}) @@ -1517,7 +1511,7 @@ if (onnxruntime_USE_XNNPACK) "${ONNXRUNTIME_ROOT}/core/providers/shared/node_unit/node_unit.h" "${ONNXRUNTIME_ROOT}/core/providers/shared/node_unit/node_unit.cc" ) - + source_group(TREE ${REPO_ROOT} FILES ${onnxruntime_providers_xnnpack_cc_srcs}) onnxruntime_add_static_library(onnxruntime_providers_xnnpack ${onnxruntime_providers_xnnpack_cc_srcs}) onnxruntime_add_include_to_target(onnxruntime_providers_xnnpack diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/builders/helper.h b/onnxruntime/core/providers/nnapi/nnapi_builtin/builders/helper.h index 4e8c84ee15..252a875627 100644 --- a/onnxruntime/core/providers/nnapi/nnapi_builtin/builders/helper.h +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/builders/helper.h @@ -18,7 +18,7 @@ // get the actually Android system version. // If running on an actual Android system, this value will be ignored #ifndef ORT_NNAPI_MAX_SUPPORTED_API_LEVEL -#define ORT_NNAPI_MAX_SUPPORTED_API_LEVEL 30 +#define ORT_NNAPI_MAX_SUPPORTED_API_LEVEL 31 #endif namespace onnxruntime { diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h index 8f74015d14..29ca6599c3 100644 --- a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h @@ -1,8 +1,11 @@ /* Copyright 2017 The TensorFlow Authors. All Rights Reserved. + Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -42,12 +45,9 @@ enum { ANEURALNETWORKS_TENSOR_QUANT16_SYMM = 7, ANEURALNETWORKS_TENSOR_FLOAT16 = 8, ANEURALNETWORKS_TENSOR_BOOL8 = 9, - ANEURALNETWORKS_FLOAT16 = 10, ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL = 11, - ANEURALNETWORKS_TENSOR_QUANT16_ASYMM = 12, ANEURALNETWORKS_TENSOR_QUANT8_SYMM = 13, ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED = 14, - ANEURALNETWORKS_MODEL = 15, }; /** @@ -146,6 +146,10 @@ enum { ANEURALNETWORKS_HARD_SWISH = 99, ANEURALNETWORKS_FILL = 100, ANEURALNETWORKS_RANK = 101, + ANEURALNETWORKS_BATCH_MATMUL = 102, + ANEURALNETWORKS_PACK = 103, + ANEURALNETWORKS_MIRROR_PAD = 104, + ANEURALNETWORKS_REVERSE = 105, }; /** @@ -256,6 +260,10 @@ enum { * API releases. */ ANEURALNETWORKS_FEATURE_LEVEL_5 = 31, + /** Android NNAPI feature level 6 */ + ANEURALNETWORKS_FEATURE_LEVEL_6 = 1000006, + /** Android NNAPI feature level 7 */ + ANEURALNETWORKS_FEATURE_LEVEL_7 = 1000007, }; /** @@ -510,6 +518,65 @@ typedef int32_t ANeuralNetworksOperationType; */ typedef struct ANeuralNetworksDevice ANeuralNetworksDevice; +/** + * Diagnostic result codes. + */ +typedef enum { + ANNDIAG_NO_ERROR = 0, + + /** + * Failure caused by failure to load support library driver. + */ + ANNDIAG_FAILED_TO_LOAD_SL = 1, + + /** + * Failure caused by failure to register HAL service. + */ + ANNDIAG_FAILED_TO_REGISTER_SERVICE = 2, + + /** + * General failure. + */ + ANNDIAG_GENERAL_ERROR = 3, + + /** + * Invalid argument + */ + ANNDIAG_INVALID_ARGUMENT = 4, +} ANeuralNetworksDiagnosticResultCode; + +/** + * Diagnostic data class. + */ +typedef enum { + ANNDIAG_DATA_CLASS_UNKNOWN = 0, + ANNDIAG_DATA_CLASS_OTHER = 1, + ANNDIAG_DATA_CLASS_FLOAT32 = 2, + ANNDIAG_DATA_CLASS_FLOAT16 = 3, + ANNDIAG_DATA_CLASS_QUANT = 4, + ANNDIAG_DATA_CLASS_MIXED = 5 +} ANeuralNetworksDiagnosticDataClass; + +/** + * Diagnostic execution mode. + */ +typedef enum { + ANNDIAG_EXECUTION_MODE_UNKNOWN = 0, + ANNDIAG_EXECUTION_MODE_ASYNC = 1, + ANNDIAG_EXECUTION_MODE_SYNC = 2, + ANNDIAG_EXECUTION_MODE_BURST = 3, + ANNDIAG_EXECUTION_MODE_ASYNC_WITH_DEPS = 4, +} ANeuralNetworksDiagnosticExecutionMode; + +typedef struct ANeuralNetworksDiagnosticCompilationInfo + ANeuralNetworksDiagnosticCompilationInfo; +typedef struct ANeuralNetworksDiagnosticExecutionInfo + ANeuralNetworksDiagnosticExecutionInfo; +typedef void (*ANeuralNetworksDiagnosticCompilationFinishedCallback)( + const void* context, const ANeuralNetworksDiagnosticCompilationInfo* info); +typedef void (*ANeuralNetworksDiagnosticExecutionFinishedCallback)( + const void* context, const ANeuralNetworksDiagnosticExecutionInfo* info); + // nn api function types typedef int (*ANeuralNetworksMemory_createFromFd_fn)( @@ -757,4 +824,102 @@ typedef int (*ANeuralNetworksExecution_setReusable_fn)( ANeuralNetworksExecution* execution, bool reusable); typedef int64_t (*ANeuralNetworks_getRuntimeFeatureLevel_fn)(); + +typedef int32_t (*SL_ANeuralNetworksDiagnosticCompilationInfo_getSessionId_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef int64_t ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getNnApiVersion_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef const uint8_t* ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getModelArchHash_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef const char* ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getDeviceIds_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef int32_t (*SL_ANeuralNetworksDiagnosticCompilationInfo_getErrorCode_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getInputDataClass_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getOutputDataClass_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef uint64_t ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getCompilationTimeNanos_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef bool (*SL_ANeuralNetworksDiagnosticCompilationInfo_isCachingEnabled_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef bool ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_isControlFlowUsed_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef bool ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_areDynamicTensorsUsed_fn)( + const ANeuralNetworksDiagnosticCompilationInfo* diagnosticCompilationInfo); + +typedef int32_t (*SL_ANeuralNetworksDiagnosticExecutionInfo_getSessionId_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef int64_t (*SL_ANeuralNetworksDiagnosticExecutionInfo_getNnApiVersion_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef const uint8_t* ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getModelArchHash_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef const char* ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getDeviceIds_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef ANeuralNetworksDiagnosticExecutionMode ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getExecutionMode_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getInputDataClass_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getOutputDataClass_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef uint32_t (*SL_ANeuralNetworksDiagnosticExecutionInfo_getErrorCode_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef uint64_t ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getRuntimeExecutionTimeNanos_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef uint64_t ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getDriverExecutionTimeNanos_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef uint64_t ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getHardwareExecutionTimeNanos_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef bool (*SL_ANeuralNetworksDiagnosticExecutionInfo_isCachingEnabled_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef bool (*SL_ANeuralNetworksDiagnosticExecutionInfo_isControlFlowUsed_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef bool ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_areDynamicTensorsUsed_fn)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + +typedef void (*SL_ANeuralNetworksDiagnostic_registerCallbacks_fn)( + ANeuralNetworksDiagnosticCompilationFinishedCallback compilationCallback, + ANeuralNetworksDiagnosticExecutionFinishedCallback executionCallback, + void* callbackContext); + #endif // TENSORFLOW_LITE_NNAPI_NEURALNETWORKSTYPES_H_ diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.cc b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.cc index 31eaaff739..9d18c8d228 100644 --- a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.cc +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.cc @@ -71,7 +71,6 @@ size_t OperandType::GetElementByteSize() const { element_size = 1; break; case Type::TENSOR_FLOAT16: - case Type::FLOAT16: element_size = 2; break; case Type::TENSOR_FLOAT32: @@ -87,7 +86,6 @@ size_t OperandType::GetElementByteSize() const { element_size = 1; break; case Type::TENSOR_QUANT16_SYMM: - case Type::TENSOR_QUANT16_ASYMM: element_size = 2; break; default: diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.h b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.h index 86427b0827..a01f36d981 100644 --- a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.h +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksWrapper.h @@ -16,14 +16,12 @@ // Provides C++ classes to more easily use the Neural Networks API. #ifndef ANDROID_ML_NN_RUNTIME_NEURAL_NETWORKS_WRAPPER_H #define ANDROID_ML_NN_RUNTIME_NEURAL_NETWORKS_WRAPPER_H -#include #include +#include +#include #include "NeuralNetworksTypes.h" -// Move to std::optional when we switch to c++ 17 -#include "core/common/optional.h" - namespace android { namespace nn { namespace wrapper { @@ -38,9 +36,7 @@ enum class Type { TENSOR_QUANT16_SYMM = ANEURALNETWORKS_TENSOR_QUANT16_SYMM, TENSOR_FLOAT16 = ANEURALNETWORKS_TENSOR_FLOAT16, TENSOR_BOOL8 = ANEURALNETWORKS_TENSOR_BOOL8, - FLOAT16 = ANEURALNETWORKS_FLOAT16, TENSOR_QUANT8_SYMM_PER_CHANNEL = ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL, - TENSOR_QUANT16_ASYMM = ANEURALNETWORKS_TENSOR_QUANT16_ASYMM, TENSOR_QUANT8_ASYMM_SIGNED = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED, }; @@ -81,8 +77,6 @@ inline std::string TypeToStr(const Type& type) { return "TENSOR_INT32"; } else if (type == Type::TENSOR_QUANT8_ASYMM) { return "TENSOR_QUANT8_ASYMM"; - } else if (type == Type::TENSOR_QUANT16_ASYMM) { - return "TENSOR_QUANT16_ASYMM"; } else if (type == Type::TENSOR_QUANT16_SYMM) { return "TENSOR_QUANT16_SYMM"; } else if (type == Type::BOOL) { @@ -91,8 +85,6 @@ inline std::string TypeToStr(const Type& type) { return "TENSOR_FLOAT16"; } else if (type == Type::TENSOR_BOOL8) { return "TENSOR_BOOL8"; - } else if (type == Type::FLOAT16) { - return "FLOAT16"; } else if (type == Type::TENSOR_QUANT8_SYMM_PER_CHANNEL) { return "TENSOR_QUANT8_SYMM_PER_CHANNEL"; } else if (type == Type::TENSOR_QUANT8_ASYMM_SIGNED) { @@ -131,7 +123,7 @@ struct OperandType { ANeuralNetworksOperandType operandType; Type type; std::vector dimensions; - onnxruntime::optional channelQuant; + std::optional channelQuant; explicit OperandType(Type type, const std::vector& d, float scale = 0.0f, int32_t zeroPoint = 0); explicit OperandType(Type type, const std::vector& d, SymmPerChannelQuantParams&& channelQuant); diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.cc b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.cc index 5297642093..cdf1075beb 100644 --- a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.cc +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.cc @@ -1,8 +1,11 @@ /* Copyright 2017 The TensorFlow Authors. All Rights Reserved. + Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -11,9 +14,6 @@ limitations under the License. ==============================================================================*/ #include "nnapi_implementation.h" -// use real implementation on Android. -// use stub on other platforms to allow unit testing model building. -#if defined(__ANDROID__) #include #include #include @@ -201,10 +201,14 @@ const NnApi LoadNnApi() { LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksModel_finish); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksModel_addOperand); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksModel_setOperandValue); - LOAD_FUNCTION_OPTIONAL(libneuralnetworks, ANeuralNetworksModel_setOperandSymmPerChannelQuantParams); - LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksModel_setOperandValueFromMemory); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + ANeuralNetworksModel_setOperandSymmPerChannelQuantParams); + LOAD_FUNCTION(libneuralnetworks, + ANeuralNetworksModel_setOperandValueFromMemory); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksModel_addOperation); - LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksModel_identifyInputsAndOutputs); + LOAD_FUNCTION(libneuralnetworks, + ANeuralNetworksModel_identifyInputsAndOutputs); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksCompilation_create); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksCompilation_free); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksCompilation_setPreference); @@ -214,7 +218,8 @@ const NnApi LoadNnApi() { LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksExecution_setInput); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksExecution_setInputFromMemory); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksExecution_setOutput); - LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksExecution_setOutputFromMemory); + LOAD_FUNCTION(libneuralnetworks, + ANeuralNetworksExecution_setOutputFromMemory); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksExecution_startCompute); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksEvent_wait); LOAD_FUNCTION(libneuralnetworks, ANeuralNetworksEvent_free); @@ -308,6 +313,83 @@ const NnApi LoadNnApi() { ANeuralNetworksExecution_enableInputAndOutputPadding); LOAD_FUNCTION_OPTIONAL(libneuralnetworks, ANeuralNetworksExecution_setReusable); + + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getSessionId); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getNnApiVersion); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getModelArchHash); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getDeviceIds); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getErrorCode); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getInputDataClass); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getOutputDataClass); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_getCompilationTimeNanos); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_isCachingEnabled); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_isControlFlowUsed); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticCompilationInfo_areDynamicTensorsUsed); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getSessionId); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getNnApiVersion); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getModelArchHash); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getDeviceIds); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getExecutionMode); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getInputDataClass); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getOutputDataClass); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getErrorCode); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getRuntimeExecutionTimeNanos); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getDriverExecutionTimeNanos); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_getHardwareExecutionTimeNanos); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_isCachingEnabled); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_isControlFlowUsed); + LOAD_FUNCTION_OPTIONAL( + libneuralnetworks, + SL_ANeuralNetworksDiagnosticExecutionInfo_areDynamicTensorsUsed); + #ifndef __ANDROID__ // If libneuralnetworks.so is loaded, but android_sdk_version is not set, // then determine android_sdk_version by testing which functions are @@ -329,173 +411,6 @@ const NnApi LoadNnApi() { } // namespace -#else -// -// Stub out the API with default implementations that do nothing. -// -#include "core/providers/nnapi/nnapi_builtin/builders/helper.h" -#include "core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h" - -const NnApi LoadNnApi() { - NnApi nnapi = {}; - nnapi.android_sdk_version = ORT_NNAPI_MAX_SUPPORTED_API_LEVEL; - nnapi.nnapi_runtime_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_5; - - nnapi.ANeuralNetworksMemory_createFromFd = - [](size_t, int, int, size_t, ANeuralNetworksMemory**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksMemory_free = [](ANeuralNetworksMemory*) {}; - nnapi.ANeuralNetworksModel_create = [](ANeuralNetworksModel**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksModel_free = [](ANeuralNetworksModel*) {}; - nnapi.ANeuralNetworksModel_finish = [](ANeuralNetworksModel*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksModel_addOperand = [](ANeuralNetworksModel*, const ANeuralNetworksOperandType*) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksModel_setOperandValue = [](ANeuralNetworksModel*, int32_t, const void*, size_t) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksModel_setOperandSymmPerChannelQuantParams = - [](ANeuralNetworksModel*, int32_t, const ANeuralNetworksSymmPerChannelQuantParams*) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksModel_setOperandValueFromMemory = - [](ANeuralNetworksModel*, int32_t, const ANeuralNetworksMemory*, size_t, size_t) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksModel_addOperation = - [](ANeuralNetworksModel*, ANeuralNetworksOperationType, uint32_t, const uint32_t*, uint32_t, const uint32_t*) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksModel_identifyInputsAndOutputs = - [](ANeuralNetworksModel*, uint32_t, const uint32_t*, uint32_t, const uint32_t*) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksModel_relaxComputationFloat32toFloat16 = - [](ANeuralNetworksModel*, bool) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksCompilation_create = - [](ANeuralNetworksModel*, ANeuralNetworksCompilation**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksCompilation_free = [](ANeuralNetworksCompilation*) {}; - nnapi.ANeuralNetworksCompilation_setPreference = - [](ANeuralNetworksCompilation*, int32_t) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksCompilation_finish = - [](ANeuralNetworksCompilation*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_create = - [](ANeuralNetworksCompilation*, ANeuralNetworksExecution**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_free = [](ANeuralNetworksExecution*) {}; - nnapi.ANeuralNetworksExecution_setInput = - [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, const void*, size_t) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksExecution_setInputFromMemory = - [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, const ANeuralNetworksMemory*, size_t, size_t) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksExecution_setOutput = - [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, void*, size_t) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksExecution_setOutputFromMemory = - [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, const ANeuralNetworksMemory*, size_t, size_t) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksExecution_startCompute = - [](ANeuralNetworksExecution*, ANeuralNetworksEvent**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksEvent_wait = [](ANeuralNetworksEvent*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksEvent_free = [](ANeuralNetworksEvent*) {}; - nnapi.ASharedMemory_create = [](const char*, size_t) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworks_getDeviceCount = [](uint32_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworks_getDevice = [](uint32_t, ANeuralNetworksDevice**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksDevice_getName = - [](const ANeuralNetworksDevice*, const char**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksDevice_getVersion = - [](const ANeuralNetworksDevice*, const char**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksDevice_getFeatureLevel = - [](const ANeuralNetworksDevice*, int64_t* feature_level) { - *feature_level = ANEURALNETWORKS_FEATURE_LEVEL_5; - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksDevice_getType = - [](const ANeuralNetworksDevice*, int32_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksModel_getSupportedOperationsForDevices = - [](const ANeuralNetworksModel*, const ANeuralNetworksDevice* const*, uint32_t, bool*) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksCompilation_createForDevices = - [](ANeuralNetworksModel*, const ANeuralNetworksDevice* const*, uint32_t, ANeuralNetworksCompilation**) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksCompilation_setCaching = - [](ANeuralNetworksCompilation*, const char*, const uint8_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksCompilation_setTimeout = - [](ANeuralNetworksCompilation*, uint64_t) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksCompilation_setPriority = - [](ANeuralNetworksCompilation*, int) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_compute = - [](ANeuralNetworksExecution*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_setTimeout = - [](ANeuralNetworksExecution*, uint64_t) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_setLoopTimeout = - [](ANeuralNetworksExecution*, uint64_t) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_getOutputOperandRank = - [](ANeuralNetworksExecution*, int32_t, uint32_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_getOutputOperandDimensions = - [](ANeuralNetworksExecution*, int32_t, uint32_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksBurst_create = - [](ANeuralNetworksCompilation*, ANeuralNetworksBurst**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksBurst_free = [](ANeuralNetworksBurst*) {}; - nnapi.ANeuralNetworksExecution_burstCompute = - [](ANeuralNetworksExecution*, ANeuralNetworksBurst*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksMemory_createFromAHardwareBuffer = - [](const AHardwareBuffer*, ANeuralNetworksMemory**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_setMeasureTiming = - [](ANeuralNetworksExecution*, bool) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_getDuration = - [](const ANeuralNetworksExecution*, int32_t, uint64_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksDevice_getExtensionSupport = - [](const ANeuralNetworksDevice*, const char*, bool*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksModel_getExtensionOperandType = - [](ANeuralNetworksModel*, const char*, uint16_t, int32_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksModel_getExtensionOperationType = - [](ANeuralNetworksModel*, const char*, uint16_t, ANeuralNetworksOperationType*) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksModel_setOperandExtensionData = - [](ANeuralNetworksModel*, int32_t, const void*, size_t) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksMemoryDesc_create = [](ANeuralNetworksMemoryDesc**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksMemoryDesc_free = [](ANeuralNetworksMemoryDesc*) {}; - nnapi.ANeuralNetworksMemoryDesc_addInputRole = - [](ANeuralNetworksMemoryDesc*, const ANeuralNetworksCompilation*, uint32_t, float) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksMemoryDesc_addOutputRole = - [](ANeuralNetworksMemoryDesc*, const ANeuralNetworksCompilation*, uint32_t, float) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksMemoryDesc_setDimensions = - [](ANeuralNetworksMemoryDesc*, uint32_t, const uint32_t*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksMemoryDesc_finish = - [](ANeuralNetworksMemoryDesc*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksMemory_createFromDesc = - [](const ANeuralNetworksMemoryDesc*, ANeuralNetworksMemory**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksMemory_copy = - [](const ANeuralNetworksMemory*, const ANeuralNetworksMemory*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksEvent_createFromSyncFenceFd = - [](int, ANeuralNetworksEvent**) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksEvent_getSyncFenceFd = - [](const ANeuralNetworksEvent*, int*) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_startComputeWithDependencies = - [](ANeuralNetworksExecution*, const ANeuralNetworksEvent* const*, uint32_t, uint64_t, ANeuralNetworksEvent**) { - return int(ANEURALNETWORKS_NO_ERROR); - }; - nnapi.ANeuralNetworksExecution_enableInputAndOutputPadding = - [](ANeuralNetworksExecution*, bool) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworksExecution_setReusable = - [](ANeuralNetworksExecution*, bool) { return int(ANEURALNETWORKS_NO_ERROR); }; - nnapi.ANeuralNetworks_getRuntimeFeatureLevel = []() { return int64_t(ANEURALNETWORKS_FEATURE_LEVEL_5); }; - - return nnapi; -} -#endif // defined(__ANDROID__) - const NnApi* NnApiImplementation() { static const NnApi nnapi = LoadNnApi(); return &nnapi; diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.h b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.h index 9471643230..d3d6da8364 100644 --- a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.h +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.h @@ -1,8 +1,11 @@ /* Copyright 2017 The TensorFlow Authors. All Rights Reserved. + Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -1781,6 +1784,326 @@ struct NnApi { * Available since NNAPI feature level 5. */ int64_t (*ANeuralNetworks_getRuntimeFeatureLevel)(); + + /** + * Gets the ID that identifies a single session of client interacting with + * NNAPI runtime. + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Session info id. + */ + int32_t (*SL_ANeuralNetworksDiagnosticCompilationInfo_getSessionId)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets NNAPI version. + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return NNAPI version. + */ + int64_t (*SL_ANeuralNetworksDiagnosticCompilationInfo_getNnApiVersion)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets the hash of the model architecture (without weights). + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Model hash. + */ + const uint8_t* ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getModelArchHash)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets the device IDs as a comma-concatenated string. + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Device ID. + */ + const char* (*SL_ANeuralNetworksDiagnosticCompilationInfo_getDeviceIds)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets the error code. + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Error code. + */ + int32_t (*SL_ANeuralNetworksDiagnosticCompilationInfo_getErrorCode)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets the type of tensors used for inputs. + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Input data class. + */ + ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getInputDataClass)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets the type of tensors used for outputs. + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Output data class. + */ + ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getOutputDataClass)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets how many nanoseconds elapsed when compiling the model. + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Time to compile the model in nanoseconds. UINT64_MAX indicates that + * timing information is not available. + */ + uint64_t ( + *SL_ANeuralNetworksDiagnosticCompilationInfo_getCompilationTimeNanos)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Is caching enabled? + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Whether caching is enabled. + */ + bool (*SL_ANeuralNetworksDiagnosticCompilationInfo_isCachingEnabled)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Is control flow used? + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Whether control flow was used. + */ + bool (*SL_ANeuralNetworksDiagnosticCompilationInfo_isControlFlowUsed)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Are dynamic tensors used? + * + * @param diagnosticCompilationInfo The NNAPI diagnostic compilation info + * object. + * @return Whether dynamic tensors were used. + */ + bool (*SL_ANeuralNetworksDiagnosticCompilationInfo_areDynamicTensorsUsed)( + const ANeuralNetworksDiagnosticCompilationInfo* + diagnosticCompilationInfo); + + /** + * Gets the ID that identifies a single session of client interacting with + * NNAPI runtime. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Session info id. + */ + int32_t (*SL_ANeuralNetworksDiagnosticExecutionInfo_getSessionId)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets NNAPI version. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return NNAPI version. + */ + int64_t (*SL_ANeuralNetworksDiagnosticExecutionInfo_getNnApiVersion)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the hash of the model architecture (without weights). + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Model hash. + */ + const uint8_t* (*SL_ANeuralNetworksDiagnosticExecutionInfo_getModelArchHash)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the device IDs as a comma-concatenated string. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Device ID. + */ + const char* (*SL_ANeuralNetworksDiagnosticExecutionInfo_getDeviceIds)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the execution mode. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Execution mode. + */ + ANeuralNetworksDiagnosticExecutionMode ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getExecutionMode)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the input data class. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Input data class. + */ + ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getInputDataClass)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the output data class. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Output data class. + */ + ANeuralNetworksDiagnosticDataClass ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getOutputDataClass)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the error code. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Error code. + */ + uint32_t (*SL_ANeuralNetworksDiagnosticExecutionInfo_getErrorCode)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the time taken to execute from runtime, including runtime/ipc + * overhead. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Time taken to execute as measured by the runtime in nanoseconds. + * UINT64_MAX indicates that timing information is not available. + */ + uint64_t ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getRuntimeExecutionTimeNanos)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the time taken to execute in the driver, excluding runtime/ipc + * overhead. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Time taken to execute on the driver in nanoseconds. UINT64_MAX + * indicates that timing information is not available. + */ + uint64_t ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getDriverExecutionTimeNanos)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Gets the time taken to execute on the hardware, excluding driver overhead. + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Time taken to execute on the hardware in nanoseconds. UINT64_MAX + * indicates that timing information is not available. + */ + uint64_t ( + *SL_ANeuralNetworksDiagnosticExecutionInfo_getHardwareExecutionTimeNanos)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Is caching enabled? + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Whether caching is enabled. + */ + bool (*SL_ANeuralNetworksDiagnosticExecutionInfo_isCachingEnabled)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Is control flow used? + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Whether control flow was used. + */ + bool (*SL_ANeuralNetworksDiagnosticExecutionInfo_isControlFlowUsed)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Are dynamic tensors used? + * + * @param diagnosticExecutionInfo The NNAPI diagnostic compilation info + * object. + * @return Whether dynamic tensors were used. + */ + bool (*SL_ANeuralNetworksDiagnosticExecutionInfo_areDynamicTensorsUsed)( + const ANeuralNetworksDiagnosticExecutionInfo* diagnosticExecutionInfo); + + /** + * Sets the callbacks to be called when compilations or executions finish. + * + * Example usage: + * + * // Callback to be invoked whenever a compilation has completed. + * void compilationCallback(void* context, + * ANeuralNetworksDiagnosticCompilationInfo* info) { + * // The context object can be used to store state without the use of a + * global variable. ExampleLoggerObject* logger = + * static_cast(context); + * + * // Calls to getters to get the details... + * const int32_t sessionId = + * ANeuralNetworksDiagnosticCompilationInfo_getSessionId(info); + * + * ... + * + * logger->write(...); + * } + * + * void executionCallback(void* context, + * ANeuralNetworksDiagnosticExecutionInfo* info) { + * ... + * } + * + * ExampleLoggerObject exampleLoggerObject; + * ANeuralNetworksDiagnostic_registerCallbacks(&compilationCallback, + * &executionCallback, static_cast(&exampleLoggerObject)); + * + * @param compilationCallback The compilation callback to set. + * @param executionCallback The execution callback to set. + * @param callbackContext The context to be passed to the callbacks when they + * are invoked. The context object may be used by multiple threads + * simulatenously, so it must be thread-safe. + */ + void (*SL_ANeuralNetworksDiagnostic_registerCallbacks)( + ANeuralNetworksDiagnosticCompilationFinishedCallback compilationCallback, + ANeuralNetworksDiagnosticExecutionFinishedCallback executionCallback, + void* callbackContext); }; /** @@ -1790,4 +2113,4 @@ struct NnApi { */ const NnApi* NnApiImplementation(); -#endif // TENSORFLOW_LITE_NNAPI_NNAPI_IMPLEMENTATION_H_ \ No newline at end of file +#endif // TENSORFLOW_LITE_NNAPI_NNAPI_IMPLEMENTATION_H_ diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation_stub.cc b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation_stub.cc new file mode 100644 index 0000000000..0359d69909 --- /dev/null +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation_stub.cc @@ -0,0 +1,245 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +#include "core/providers/nnapi/nnapi_builtin/nnapi_lib/nnapi_implementation.h" + +// +// Stub out the API with default implementations that do nothing. +// +#include "core/providers/nnapi/nnapi_builtin/builders/helper.h" +#include "core/providers/nnapi/nnapi_builtin/nnapi_lib/NeuralNetworksTypes.h" + +namespace { +const NnApi LoadNnApi() { + NnApi nnapi = {}; + nnapi.android_sdk_version = ORT_NNAPI_MAX_SUPPORTED_API_LEVEL; + nnapi.nnapi_runtime_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_7; + + nnapi.ANeuralNetworksMemory_createFromFd = + [](size_t, int, int, size_t, ANeuralNetworksMemory**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksMemory_free = [](ANeuralNetworksMemory*) {}; + nnapi.ANeuralNetworksModel_create = + [](ANeuralNetworksModel**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksModel_free = [](ANeuralNetworksModel*) {}; + nnapi.ANeuralNetworksModel_finish = [](ANeuralNetworksModel*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksModel_addOperand = [](ANeuralNetworksModel*, const ANeuralNetworksOperandType*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_setOperandValue = [](ANeuralNetworksModel*, int32_t, const void*, size_t) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_setOperandSymmPerChannelQuantParams = + [](ANeuralNetworksModel*, int32_t, const ANeuralNetworksSymmPerChannelQuantParams*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_setOperandValueFromMemory = + [](ANeuralNetworksModel*, int32_t, const ANeuralNetworksMemory*, size_t, size_t) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_addOperation = + [](ANeuralNetworksModel*, ANeuralNetworksOperationType, uint32_t, const uint32_t*, uint32_t, const uint32_t*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_identifyInputsAndOutputs = + [](ANeuralNetworksModel*, uint32_t, const uint32_t*, uint32_t, const uint32_t*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_relaxComputationFloat32toFloat16 = + [](ANeuralNetworksModel*, bool) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksCompilation_create = + [](ANeuralNetworksModel*, ANeuralNetworksCompilation**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksCompilation_free = [](ANeuralNetworksCompilation*) {}; + nnapi.ANeuralNetworksCompilation_setPreference = + [](ANeuralNetworksCompilation*, int32_t) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksCompilation_finish = + [](ANeuralNetworksCompilation*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_create = + [](ANeuralNetworksCompilation*, ANeuralNetworksExecution**) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksExecution_free = [](ANeuralNetworksExecution*) {}; + nnapi.ANeuralNetworksExecution_setInput = + [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, const void*, size_t) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksExecution_setInputFromMemory = + [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, const ANeuralNetworksMemory*, size_t, + size_t) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksExecution_setOutput = + [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, void*, size_t) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksExecution_setOutputFromMemory = + [](ANeuralNetworksExecution*, int32_t, const ANeuralNetworksOperandType*, const ANeuralNetworksMemory*, size_t, + size_t) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksExecution_startCompute = + [](ANeuralNetworksExecution*, ANeuralNetworksEvent**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksEvent_wait = [](ANeuralNetworksEvent*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksEvent_free = [](ANeuralNetworksEvent*) {}; + nnapi.ASharedMemory_create = [](const char*, size_t) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworks_getDeviceCount = [](uint32_t*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworks_getDevice = + [](uint32_t, ANeuralNetworksDevice**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksDevice_getName = + [](const ANeuralNetworksDevice*, const char**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksDevice_getVersion = + [](const ANeuralNetworksDevice*, const char**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksDevice_getFeatureLevel = + [](const ANeuralNetworksDevice*, int64_t* feature_level) { + *feature_level = ANEURALNETWORKS_FEATURE_LEVEL_7; + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksDevice_getType = + [](const ANeuralNetworksDevice*, int32_t*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksModel_getSupportedOperationsForDevices = + [](const ANeuralNetworksModel*, const ANeuralNetworksDevice* const*, uint32_t, bool*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksCompilation_createForDevices = + [](ANeuralNetworksModel*, const ANeuralNetworksDevice* const*, uint32_t, ANeuralNetworksCompilation**) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksCompilation_setCaching = + [](ANeuralNetworksCompilation*, const char*, const uint8_t*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksCompilation_setTimeout = + [](ANeuralNetworksCompilation*, uint64_t) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksCompilation_setPriority = + [](ANeuralNetworksCompilation*, int) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_compute = + [](ANeuralNetworksExecution*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_setTimeout = + [](ANeuralNetworksExecution*, uint64_t) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_setLoopTimeout = + [](ANeuralNetworksExecution*, uint64_t) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_getOutputOperandRank = + [](ANeuralNetworksExecution*, int32_t, uint32_t*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_getOutputOperandDimensions = + [](ANeuralNetworksExecution*, int32_t, uint32_t*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksBurst_create = + [](ANeuralNetworksCompilation*, ANeuralNetworksBurst**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksBurst_free = [](ANeuralNetworksBurst*) {}; + nnapi.ANeuralNetworksExecution_burstCompute = + [](ANeuralNetworksExecution*, ANeuralNetworksBurst*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksMemory_createFromAHardwareBuffer = + [](const AHardwareBuffer*, ANeuralNetworksMemory**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_setMeasureTiming = + [](ANeuralNetworksExecution*, bool) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_getDuration = + [](const ANeuralNetworksExecution*, int32_t, uint64_t*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksDevice_getExtensionSupport = + [](const ANeuralNetworksDevice*, const char*, bool*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksModel_getExtensionOperandType = + [](ANeuralNetworksModel*, const char*, uint16_t, int32_t*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_getExtensionOperationType = + [](ANeuralNetworksModel*, const char*, uint16_t, ANeuralNetworksOperationType*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksModel_setOperandExtensionData = + [](ANeuralNetworksModel*, int32_t, const void*, size_t) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksMemoryDesc_create = + [](ANeuralNetworksMemoryDesc**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksMemoryDesc_free = [](ANeuralNetworksMemoryDesc*) {}; + nnapi.ANeuralNetworksMemoryDesc_addInputRole = + [](ANeuralNetworksMemoryDesc*, const ANeuralNetworksCompilation*, uint32_t, float) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksMemoryDesc_addOutputRole = + [](ANeuralNetworksMemoryDesc*, const ANeuralNetworksCompilation*, uint32_t, float) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksMemoryDesc_setDimensions = + [](ANeuralNetworksMemoryDesc*, uint32_t, const uint32_t*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksMemoryDesc_finish = + [](ANeuralNetworksMemoryDesc*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksMemory_createFromDesc = + [](const ANeuralNetworksMemoryDesc*, ANeuralNetworksMemory**) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksMemory_copy = + [](const ANeuralNetworksMemory*, const ANeuralNetworksMemory*) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksEvent_createFromSyncFenceFd = + [](int, ANeuralNetworksEvent**) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksEvent_getSyncFenceFd = + [](const ANeuralNetworksEvent*, int*) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_startComputeWithDependencies = + [](ANeuralNetworksExecution*, const ANeuralNetworksEvent* const*, uint32_t, uint64_t, ANeuralNetworksEvent**) { + return static_cast(ANEURALNETWORKS_NO_ERROR); + }; + nnapi.ANeuralNetworksExecution_enableInputAndOutputPadding = + [](ANeuralNetworksExecution*, bool) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworksExecution_setReusable = + [](ANeuralNetworksExecution*, bool) { return static_cast(ANEURALNETWORKS_NO_ERROR); }; + nnapi.ANeuralNetworks_getRuntimeFeatureLevel = []() { return int64_t(ANEURALNETWORKS_FEATURE_LEVEL_7); }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getSessionId = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> int32_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getNnApiVersion = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> int64_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getModelArchHash = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> const uint8_t* { return nullptr; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getDeviceIds = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> const char* { return ""; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getErrorCode = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> int32_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getInputDataClass = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> ANeuralNetworksDiagnosticDataClass { return {}; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getOutputDataClass = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> ANeuralNetworksDiagnosticDataClass { return {}; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_getCompilationTimeNanos = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> uint64_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_isCachingEnabled = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> bool { return false; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_isControlFlowUsed = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> bool { return false; }; + nnapi.SL_ANeuralNetworksDiagnosticCompilationInfo_areDynamicTensorsUsed = + [](const ANeuralNetworksDiagnosticCompilationInfo*) -> bool { return false; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getSessionId = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> int32_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getNnApiVersion = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> int64_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getModelArchHash = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> const uint8_t* { return nullptr; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getDeviceIds = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> const char* { return ""; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getExecutionMode = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> ANeuralNetworksDiagnosticExecutionMode { return {}; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getInputDataClass = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> ANeuralNetworksDiagnosticDataClass { return {}; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getOutputDataClass = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> ANeuralNetworksDiagnosticDataClass { return {}; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getErrorCode = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> uint32_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getRuntimeExecutionTimeNanos = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> uint64_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getDriverExecutionTimeNanos = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> uint64_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_getHardwareExecutionTimeNanos = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> uint64_t { return 0; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_isCachingEnabled = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> bool { return false; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_isControlFlowUsed = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> bool { return false; }; + nnapi.SL_ANeuralNetworksDiagnosticExecutionInfo_areDynamicTensorsUsed = + [](const ANeuralNetworksDiagnosticExecutionInfo*) -> bool { return false; }; + nnapi.SL_ANeuralNetworksDiagnostic_registerCallbacks = + [](ANeuralNetworksDiagnosticCompilationFinishedCallback, + ANeuralNetworksDiagnosticExecutionFinishedCallback, + void*) -> void {}; + + return nnapi; +} +} // namespace + +const NnApi* NnApiImplementation() { + static const NnApi nnapi = LoadNnApi(); + return &nnapi; +} diff --git a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/readme.txt b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/readme.txt index 7627423b9e..30a95b89a2 100644 --- a/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/readme.txt +++ b/onnxruntime/core/providers/nnapi/nnapi_builtin/nnapi_lib/readme.txt @@ -1,8 +1,8 @@ 1. Files: nnapi_implementation.h nnapi_implementation.cc NeuralNetworksTypes.h -These files are copied from TensorFlow Lite project -https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/nnapi +These files are copied from TensorFlow Lite project (release tag v2.9.1) +https://github.com/tensorflow/tensorflow/tree/v2.9.1/tensorflow/lite/nnapi These files do not need to be updated frequently, unless new functionalities are introduced in new Android OS versions, and we will integrate the new functionalities. @@ -10,15 +10,19 @@ introduced in new Android OS versions, and we will integrate the new functionali The modifications to these files, NeuralNetworksTypes.h * The enum ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES was added. - * The operation ANEURALNETWORKS_GROUPED_CONV_2D was added. nnapi_implementation.h/cc + * Include paths were updated + * In nnapi_implementation.cc, NeuralNetworksSupportLibraryImpl.h was replaced with NeuralNetworksTypes.h. + We don't keep a copy of NeuralNetworksSupportLibraryImpl.h yet. * CreateNnApiFromSupportLibrary was removed - * A stub implementation was added to enable unit testing on non-Android platforms * [TODO, add support of CreateNnApiFromSupportLibrary for Android 12] 2. Files: NeuralNetworksWrapper.h NeuralNetworksWrapper.cc - This NeuralNetworksWrapper.h is copied from The Android Open Source Project - * https://android.googlesource.com/platform/frameworks/ml/+/refs/heads/master/nn/runtime/include/ - This file is heavily modified, and an extra NeuralNetworksWrapper.cc was added. - Please do not update these files. +This NeuralNetworksWrapper.h is copied from The Android Open Source Project + * https://android.googlesource.com/platform/frameworks/ml/+/refs/heads/master/nn/runtime/include/ +This file is heavily modified, and an extra NeuralNetworksWrapper.cc was added. +Please do not update these files. + +3. File: nnapi_implementation_stub.cc +A stub implementation of nnapi_implementation.h was added to enable unit testing on non-Android platforms.