From aa4561349c3e00483998689c0a7ecbdb904e03d5 Mon Sep 17 00:00:00 2001 From: RyanUnderhill Date: Mon, 17 Dec 2018 17:46:05 -0800 Subject: [PATCH 1/3] More Ort prefix changes for consistency --- .../core/framework/onnx_object_cxx.h | 6 +- .../core/session/onnxruntime_c_api.h | 235 +++++++++--------- .../core/session/onnxruntime_cxx_api.h | 26 +- onnxruntime/core/framework/allocator.cc | 2 +- onnxruntime/core/framework/error_code.cc | 10 +- .../core/framework/error_code_helper.h | 2 +- onnxruntime/core/framework/onnx_object.cc | 6 +- .../core/framework/onnxruntime_typeinfo.cc | 36 +-- .../core/framework/onnxruntime_typeinfo.h | 8 +- .../core/framework/tensor_type_and_shape.cc | 38 +-- .../providers/cpu/cpu_provider_factory.cc | 2 +- onnxruntime/core/providers/cpu/symbols.txt | 16 +- .../providers/cuda/cuda_provider_factory.cc | 2 +- .../mkldnn/mkldnn_provider_factory.cc | 2 +- .../session/default_cpu_allocator_c_api.cc | 4 +- onnxruntime/core/session/onnxruntime_c_api.cc | 166 ++++++------- onnxruntime/test/onnx/TestCase.cc | 26 +- onnxruntime/test/onnx/TestCase.h | 2 +- onnxruntime/test/onnx/main.cc | 8 +- onnxruntime/test/onnx/runner.cc | 38 +-- onnxruntime/test/onnx/runner.h | 10 +- onnxruntime/test/onnxruntime_exec/Runtime.h | 2 +- .../shared_lib/fns_candy_style_transfer.c | 28 +-- onnxruntime/test/shared_lib/test_allocator.cc | 4 +- onnxruntime/test/shared_lib/test_inference.cc | 28 +-- onnxruntime/test/shared_lib/test_io_types.cc | 6 +- onnxruntime/test/util/compare_mlvalue.cc | 8 +- .../test/util/include/test/compare_mlvalue.h | 2 +- .../test/util/include/test_allocator.h | 2 +- 29 files changed, 360 insertions(+), 365 deletions(-) diff --git a/include/onnxruntime/core/framework/onnx_object_cxx.h b/include/onnxruntime/core/framework/onnx_object_cxx.h index f47389ba0cd2c..9677f8bdda980 100644 --- a/include/onnxruntime/core/framework/onnx_object_cxx.h +++ b/include/onnxruntime/core/framework/onnx_object_cxx.h @@ -16,10 +16,10 @@ namespace onnxruntime { template class ObjectBase { private: - static ONNXObject static_cls; + static OrtObject static_cls; protected: - const ONNXObject* const ORT_ATTRIBUTE_UNUSED cls_; + const OrtObject* const ORT_ATTRIBUTE_UNUSED cls_; std::atomic_int ref_count; ObjectBase() : cls_(&static_cls), ref_count(1) { } @@ -39,7 +39,7 @@ class ObjectBase { }; template -ONNXObject ObjectBase::static_cls = {ObjectBase::OrtAddRefImpl, ObjectBase::OrtReleaseImpl}; +OrtObject ObjectBase::static_cls = {ObjectBase::OrtAddRefImpl, ObjectBase::OrtReleaseImpl}; } // namespace onnxruntime diff --git a/include/onnxruntime/core/session/onnxruntime_c_api.h b/include/onnxruntime/core/session/onnxruntime_c_api.h index 4c9a8b56402f0..1be5004ac1fa6 100644 --- a/include/onnxruntime/core/session/onnxruntime_c_api.h +++ b/include/onnxruntime/core/session/onnxruntime_c_api.h @@ -15,7 +15,7 @@ extern "C" { #endif -// SAL2 staffs +// SAL2 Definitions #ifndef _WIN32 #define _In_ #define _In_opt_ @@ -46,7 +46,7 @@ extern "C" { #define ORT_MUST_USE_RESULT __attribute__((warn_unused_result)) #endif -//Any pointer marked with _In_ or _Out_, cannot be NULL. Caller should ensure that. +// Any pointer marked with _In_ or _Out_, cannot be NULL. #ifdef __cplusplus // Windows users should use unicode paths when possible to bypass the MAX_PATH limitation @@ -74,58 +74,75 @@ typedef enum OrtErrorCode { ORT_REQUIREMENT_NOT_REGISTERED = 12 } OrtErrorCode; -// ONNXStatus is always returned as a pointer. nullptr indicates success -typedef void ONNXStatus; +// OrtStatus is always returned as a pointer. nullptr indicates success +typedef void OrtStatus; // __VA_ARGS__ on Windows and Linux are different #define ORT_API(RETURN_TYPE, NAME, ...) \ ORT_EXPORT RETURN_TYPE ORT_API_CALL NAME(__VA_ARGS__) NO_EXCEPTION #define ORT_API_STATUS(NAME, ...) \ - ORT_EXPORT ONNXStatus* ORT_API_CALL NAME(__VA_ARGS__) NO_EXCEPTION ORT_MUST_USE_RESULT + ORT_EXPORT OrtStatus* ORT_API_CALL NAME(__VA_ARGS__) NO_EXCEPTION ORT_MUST_USE_RESULT // Used in *.cc files. Almost as same as ORT_API_STATUS, except without ORT_MUST_USE_RESULT #define ORT_API_STATUS_IMPL(NAME, ...) \ - ORT_EXPORT ONNXStatus* ORT_API_CALL NAME(__VA_ARGS__) NO_EXCEPTION + ORT_EXPORT OrtStatus* ORT_API_CALL NAME(__VA_ARGS__) NO_EXCEPTION -#define DEFINE_RUNTIME_CLASS2(NAME, TYPE) \ - ORT_API(void, Release##NAME, _Frees_ptr_opt_ TYPE* input); +#define ORT_RUNTIME_CLASS2(NAME, TYPE) \ + ORT_API(void, OrtRelease##NAME, _Frees_ptr_opt_ TYPE* input); -#define DEFINE_RUNTIME_CLASS(X) \ - struct X; \ - typedef struct X X; \ - DEFINE_RUNTIME_CLASS2(X, X) +#define ORT_RUNTIME_CLASS(X) \ + struct Ort##X; \ + typedef struct Ort##X Ort##X; \ + ORT_RUNTIME_CLASS2(X, Ort##X) -// ONNXStatus* is pointer to something like this: -// struct ONNXStatus { +// OrtStatus* is pointer to something like this: +// struct OrtStatus { // OrtErrorCode code; // char msg[]; // a null-terminated string, var length // } -DEFINE_RUNTIME_CLASS2(ONNXStatus, void); +ORT_RUNTIME_CLASS2(Status, void); + +// The actual types defined have an Ort prefix +ORT_RUNTIME_CLASS(Provider); +ORT_RUNTIME_CLASS(AllocatorInfo); +ORT_RUNTIME_CLASS(Session); +ORT_RUNTIME_CLASS(Value); +ORT_RUNTIME_CLASS(ValueList); + +struct OrtTypeInfo; +typedef struct OrtTypeInfo OrtTypeInfo; +struct OrtTensorTypeAndShapeInfo; +typedef struct OrtTensorTypeAndShapeInfo OrtTensorTypeAndShapeInfo; +struct OrtRunOptions; +typedef struct OrtRunOptions OrtRunOptions; +struct OrtSessionOptions; +typedef struct OrtSessionOptions OrtSessionOptions; +struct OrtEnv; +typedef struct OrtEnv OrtEnv; /** - * \param msg A null-terminated string. Its content will be copied into the newly created ONNXStatus + * \param msg A null-terminated string. Its content will be copied into the newly created OrtStatus */ -ORT_API(ONNXStatus*, CreateONNXStatus, OrtErrorCode code, _In_ const char* msg) +ORT_API(OrtStatus*, OrtCreateStatus, OrtErrorCode code, _In_ const char* msg) ORT_ALL_ARGS_NONNULL; -ORT_API(OrtErrorCode, OrtGetErrorCode, _In_ const ONNXStatus* status) +ORT_API(OrtErrorCode, OrtGetErrorCode, _In_ const OrtStatus* status) ORT_ALL_ARGS_NONNULL; /** * \param status must not be NULL * \return The error message inside the `status`. Don't free the returned value. */ -ORT_API(const char*, OrtGetErrorMessage, _In_ const ONNXStatus* status) +ORT_API(const char*, OrtGetErrorMessage, _In_ const OrtStatus* status) ORT_ALL_ARGS_NONNULL; // // Tensor Type and Shapes // -struct OrtTensorTypeAndShapeInfo; -//copied from TensorProto::DataType -//Currently, Ort doesn't support complex64, complex128, bfloat16 types -typedef enum OrtTensorElementDataType { +// Copied from TensorProto::DataType +// Currently, Ort doesn't support complex64, complex128, bfloat16 types +typedef enum ONNXTensorElementDataType { ONNX_TENSOR_ELEMENT_DATA_TYPE_UNDEFINED = 0, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT = 1, // maps to c type float ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8 = 2, // maps to c type uint8_t @@ -143,42 +160,40 @@ typedef enum OrtTensorElementDataType { ONNX_TENSOR_ELEMENT_DATA_TYPE_COMPLEX64 = 14, // complex with float32 real and imaginary components ONNX_TENSOR_ELEMENT_DATA_TYPE_COMPLEX128 = 15, // complex with float64 real and imaginary components ONNX_TENSOR_ELEMENT_DATA_TYPE_BFLOAT16 = 16, // Non-IEEE floating-point format based on IEEE754 single-precision -} OrtTensorElementDataType; - -//sync with onnx TypeProto oneof -typedef enum OrtType { - ORT_TYPE_UNKNOWN, - ORT_TYPE_TENSOR, - ORT_TYPE_SEQUENCE, - ORT_TYPE_MAP, - ORT_TYPE_OPAQUE, - ORT_TYPE_SPARSETENSOR, -} OrtType; - -struct OrtTypeInfo; +} ONNXTensorElementDataType; + +// Sync with onnx TypeProto oneof +typedef enum ONNXType { + ONNX_TYPE_UNKNOWN, + ONNX_TYPE_TENSOR, + ONNX_TYPE_SEQUENCE, + ONNX_TYPE_MAP, + ONNX_TYPE_OPAQUE, + ONNX_TYPE_SPARSETENSOR, +} ONNXType; /** * Don't free the returned value */ -ORT_API(const struct OrtTensorTypeAndShapeInfo*, OrtCastTypeInfoToTensorInfo, _In_ struct OrtTypeInfo*); +ORT_API(const OrtTensorTypeAndShapeInfo*, OrtCastTypeInfoToTensorInfo, _In_ OrtTypeInfo*); /** * The retured value should be released by calling OrtReleaseObject */ -ORT_API(struct OrtTensorTypeAndShapeInfo*, OrtCreateTensorTypeAndShapeInfo); +ORT_API(OrtTensorTypeAndShapeInfo*, OrtCreateTensorTypeAndShapeInfo); -ORT_API_STATUS(OrtSetTensorElementType, _In_ struct OrtTensorTypeAndShapeInfo*, enum OrtTensorElementDataType type); +ORT_API_STATUS(OrtSetTensorElementType, _In_ OrtTensorTypeAndShapeInfo*, enum ONNXTensorElementDataType type); /** * \param info Created from OrtCreateTensorTypeAndShapeInfo() function * \param dim_values An array with length of `dim_count`. Its elements can contain negative values. * \param dim_count length of dim_values */ -ORT_API_STATUS(OrtSetDims, struct OrtTensorTypeAndShapeInfo* info, _In_ const int64_t* dim_values, size_t dim_count); +ORT_API_STATUS(OrtSetDims, OrtTensorTypeAndShapeInfo* info, _In_ const int64_t* dim_values, size_t dim_count); -ORT_API(enum OrtTensorElementDataType, OrtGetTensorElementType, _In_ const struct OrtTensorTypeAndShapeInfo*); -ORT_API(size_t, OrtGetNumOfDimensions, _In_ const struct OrtTensorTypeAndShapeInfo* info); -ORT_API(void, OrtGetDimensions, _In_ const struct OrtTensorTypeAndShapeInfo* info, _Out_ int64_t* dim_values, size_t dim_values_length); +ORT_API(enum ONNXTensorElementDataType, OrtGetTensorElementType, _In_ const OrtTensorTypeAndShapeInfo*); +ORT_API(size_t, OrtGetNumOfDimensions, _In_ const OrtTensorTypeAndShapeInfo* info); +ORT_API(void, OrtGetDimensions, _In_ const OrtTensorTypeAndShapeInfo* info, _Out_ int64_t* dim_values, size_t dim_values_length); /** * How many elements does this tensor have. @@ -191,29 +206,26 @@ ORT_API(void, OrtGetDimensions, _In_ const struct OrtTensorTypeAndShapeInfo* inf * return a negative value if unknown. (That this shape contains a symbolic variable which * represents an unknown dimension.) */ -ORT_API(int64_t, OrtGetTensorShapeElementCount, _In_ const struct OrtTensorTypeAndShapeInfo* info); -struct ONNXValue; +ORT_API(int64_t, OrtGetTensorShapeElementCount, _In_ const OrtTensorTypeAndShapeInfo* info); /** * \param out Should be freed by OrtReleaseObject after use */ -ORT_API_STATUS(OrtGetTensorShapeAndType, _In_ const struct ONNXValue* value, - _Out_ struct OrtTensorTypeAndShapeInfo** out); +ORT_API_STATUS(OrtGetTensorShapeAndType, _In_ const OrtValue* value, _Out_ OrtTensorTypeAndShapeInfo** out); /** - * Get the type information of an ONNXValue + * Get the type information of an OrtValue * \param value * \param out The returned value should be freed by OrtReleaseObject after use */ -ORT_API_STATUS(OrtGetTypeInfo, _In_ const struct ONNXValue* value, struct OrtTypeInfo** out); +ORT_API_STATUS(OrtGetTypeInfo, _In_ const OrtValue* value, OrtTypeInfo** out); -ORT_API(enum OrtType, OrtGetValueType, _In_ const struct ONNXValue* value); +ORT_API(enum ONNXType, OrtGetValueType, _In_ const OrtValue* value); // // OrtRunOptions // -struct OrtRunOptions; -typedef struct OrtRunOptions OrtRunOptions; + /** * \return A pointer of the newly created object. The pointer should be freed by OrtReleaseObject after use */ @@ -229,22 +241,19 @@ ORT_API(const char*, OrtRunOptionsGetRunTag, _In_ OrtRunOptions*); // will exit as soon as possible if the flag is true. ORT_API(void, OrtRunOptionsSetTerminate, _In_ OrtRunOptions*, _In_ bool value); -DEFINE_RUNTIME_CLASS(OrtProvider); - /** - * Just like the IUnknown interface in COM - * Every type inherented from ONNXObject should be deleted by OrtReleaseObject(...). + * Every type inherented from OrtObject should be deleted by OrtReleaseObject(...). */ -typedef struct ONNXObject { - ///returns the new reference count. +typedef struct OrtObject { + // Returns the new reference count. uint32_t(ORT_API_CALL* AddRef)(void* this_); - ///returns the new reference count. + // Returns the new reference count. uint32_t(ORT_API_CALL* Release)(void* this_); - //TODO: implement QueryInterface? -} ONNXObject; + +} OrtObject; /** - * This function is a wrapper to "(*(ONNXObject**)ptr)->AddRef(ptr)" + * This function is a wrapper to "(*(OrtObject**)ptr)->AddRef(ptr)" * WARNING: There is NO type checking in this function. * Before calling this function, caller should make sure current ref count > 0 * \return the new reference count @@ -253,22 +262,19 @@ ORT_API(uint32_t, OrtAddRefToObject, _In_ void* ptr); /** * - * A wrapper to "(*(ONNXObject**)ptr)->Release(ptr)" + * A wrapper to "(*(OrtObject**)ptr)->Release(ptr)" * WARNING: There is NO type checking in this function. * \param ptr Can be NULL. If it's NULL, this function will return zero. * \return the new reference count. */ ORT_API(uint32_t, OrtReleaseObject, _Inout_opt_ void* ptr); -//Inherented from ONNXObject +//Inherented from OrtObject typedef struct OrtProviderFactoryInterface { - ONNXObject parent; - ONNXStatus*(ORT_API_CALL* CreateProvider)(void* this_, OrtProvider** out); + OrtObject parent; + OrtStatus*(ORT_API_CALL* CreateProvider)(void* this_, OrtProvider** out); } OrtProviderFactoryInterface; -struct OrtSessionOptions; -typedef struct OrtSessionOptions OrtSessionOptions; - /** * \return A pointer of the newly created object. The pointer should be freed by OrtReleaseObject after use */ @@ -329,8 +335,6 @@ typedef enum OrtMemType { OrtMemTypeDefault = 0, // the default allocator for execution provider } OrtMemType; -DEFINE_RUNTIME_CLASS(OrtAllocatorInfo); - ORT_API_STATUS(OrtCreateAllocatorInfo, _In_ const char* name1, enum OrtAllocatorType type, int id1, enum OrtMemType mem_type1, _Out_ OrtAllocatorInfo** out); /** @@ -347,9 +351,9 @@ ORT_API(int, OrtAllocatorInfoGetId, _In_ OrtAllocatorInfo* ptr); ORT_API(OrtMemType, OrtAllocatorInfoGetMemType, _In_ OrtAllocatorInfo* ptr); ORT_API(OrtAllocatorType, OrtAllocatorInfoGetType, _In_ OrtAllocatorInfo* ptr); -//inherented from ONNXObject +//inherented from OrtObject typedef struct OrtAllocatorInterface { - struct ONNXObject parent; + struct OrtObject parent; void*(ORT_API_CALL* Alloc)(void* this_, size_t size); void(ORT_API_CALL* Free)(void* this_, void* p); const struct OrtAllocatorInfo*(ORT_API_CALL* Info)(const void* this_); @@ -359,10 +363,7 @@ typedef OrtAllocatorInterface* OrtAllocator; ORT_API(void*, OrtAllocatorAlloc, _Inout_ OrtAllocator* ptr, size_t size); ORT_API(void, OrtAllocatorFree, _Inout_ OrtAllocator* ptr, void* p); -ORT_API(const struct OrtAllocatorInfo*, OrtAllocatorGetInfo, _In_ const OrtAllocator* ptr); - -struct OrtEnv; -typedef struct OrtEnv OrtEnv; +ORT_API(const OrtAllocatorInfo*, OrtAllocatorGetInfo, _In_ const OrtAllocator* ptr); typedef enum OrtLoggingLevel { ORT_LOGGING_LEVEL_kVERBOSE = 0, @@ -391,108 +392,102 @@ ORT_API_STATUS(OrtInitializeWithCustomLogger, OrtLoggingFunction logging_functio _In_ const char* logid, _Out_ OrtEnv** out); -DEFINE_RUNTIME_CLASS(ONNXSession); - -//TODO: document the path separator convention? '/' vs '\' -//TODO: should specify the access characteristics of model_path. Is this read only during the -//execution of OrtCreateInferenceSession, or does the ONNXSession retain a handle to the file/directory -//and continue to access throughout the ONNXSession lifetime? -// What sort of access is needed to model_path : read or read/write? -//TODO: allow loading from an in-memory byte-array +// TODO: document the path separator convention? '/' vs '\' +// TODO: should specify the access characteristics of model_path. Is this read only during the +// execution of OrtCreateInferenceSession, or does the OrtSession retain a handle to the file/directory +// and continue to access throughout the OrtSession lifetime? +// What sort of access is needed to model_path : read or read/write? +// TODO: allow loading from an in-memory byte-array #ifdef _WIN32 ORT_API_STATUS(OrtCreateInferenceSession, _In_ OrtEnv* env, _In_ const wchar_t* model_path, - _In_ const OrtSessionOptions* options, _Out_ ONNXSession** out); + _In_ const OrtSessionOptions* options, _Out_ OrtSession** out); #else ORT_API_STATUS(OrtCreateInferenceSession, _In_ OrtEnv* env, _In_ const char* model_path, - _In_ const OrtSessionOptions* options, _Out_ ONNXSession** out); + _In_ const OrtSessionOptions* options, _Out_ OrtSession** out); #endif -DEFINE_RUNTIME_CLASS(ONNXValue); - -///Call OrtReleaseObject to release the returned value +// Call OrtReleaseObject to release the returned value ORT_API_STATUS(OrtCreateDefaultAllocator, _Out_ OrtAllocator** out); /** - * Create a tensor from an allocator. ReleaseONNXValue will also release the buffer inside the output value + * Create a tensor from an allocator. OrtReleaseValue will also release the buffer inside the output value * \param out will keep a reference to the allocator, without reference counting(will be fixed). Should be freed by - * calling ReleaseONNXValue + * calling OrtReleaseValue * \param type must be one of TENSOR_ELEMENT_DATA_TYPE_xxxx */ -ORT_API_STATUS(OrtCreateTensorAsONNXValue, _Inout_ OrtAllocator* allocator, - _In_ const size_t* shape, size_t shape_len, OrtTensorElementDataType type, - _Out_ ONNXValue** out); +ORT_API_STATUS(OrtCreateTensorAsOrtValue, _Inout_ OrtAllocator* allocator, + _In_ const size_t* shape, size_t shape_len, ONNXTensorElementDataType type, + _Out_ OrtValue** out); /** * Create a tensor with user's buffer. You can fill the buffer either before calling this function or after. - * p_data is owned by caller. ReleaseONNXValue won't release p_data. - * \param out Should be freed by calling ReleaseONNXValue + * p_data is owned by caller. OrtReleaseValue won't release p_data. + * \param out Should be freed by calling OrtReleaseValue */ -ORT_API_STATUS(OrtCreateTensorWithDataAsONNXValue, _In_ const OrtAllocatorInfo* info, +ORT_API_STATUS(OrtCreateTensorWithDataAsOrtValue, _In_ const OrtAllocatorInfo* info, _In_ void* p_data, size_t p_data_len, _In_ const size_t* shape, size_t shape_len, - OrtTensorElementDataType type, _Out_ ONNXValue** out); + ONNXTensorElementDataType type, _Out_ OrtValue** out); /// This function doesn't work with string tensor -/// this is a no-copy method whose pointer is only valid until the backing ONNXValue is free'd. -ORT_API_STATUS(OrtGetTensorMutableData, _Inout_ ONNXValue* value, _Out_ void** out); +/// this is a no-copy method whose pointer is only valid until the backing OrtValue is free'd. +ORT_API_STATUS(OrtGetTensorMutableData, _Inout_ OrtValue* value, _Out_ void** out); /** - * Test if an ONNXValue is a tensor + * Test if an OrtValue is a tensor * \return zero, false. non-zero true */ -ORT_API(int, OrtIsTensor, _In_ const ONNXValue* value); +ORT_API(int, OrtIsTensor, _In_ const OrtValue* value); /** * \param value A tensor created from OrtCreateTensor*** function. * \param s each A string array. Each string in this array must be null terminated. * \param s_len length of s */ -ORT_API_STATUS(OrtFillStringTensor, _In_ ONNXValue* value, _In_ const char* const* s, size_t s_len); +ORT_API_STATUS(OrtFillStringTensor, _In_ OrtValue* value, _In_ const char* const* s, size_t s_len); /** * \param value A tensor created from OrtCreateTensor*** function. * \param len total data length, not including the trailing '\0' chars. */ -ORT_API_STATUS(OrtGetStringTensorDataLength, _In_ const ONNXValue* value, _Out_ size_t* len); +ORT_API_STATUS(OrtGetStringTensorDataLength, _In_ const OrtValue* value, _Out_ size_t* len); /** * \param s string contents. Each string is NOT null-terminated. * \param value A tensor created from OrtCreateTensor*** function. * \param s_len total data length, get it from OrtGetStringTensorDataLength */ -ORT_API_STATUS(OrtGetStringTensorContent, _In_ const ONNXValue* value, _Out_ void* s, size_t s_len, +ORT_API_STATUS(OrtGetStringTensorContent, _In_ const OrtValue* value, _Out_ void* s, size_t s_len, _Out_ size_t* offsets, size_t offsets_len); -DEFINE_RUNTIME_CLASS(ONNXValueList); - -ORT_API_STATUS(OrtRunInference, _Inout_ ONNXSession* sess, +ORT_API_STATUS(OrtRunInference, _Inout_ OrtSession* sess, _In_ OrtRunOptions* run_options, - _In_ const char* const* input_names, _In_ const ONNXValue* const* input, size_t input_len, - _In_ const char* const* output_names, size_t output_names_len, _Out_ ONNXValue** output); + _In_ const char* const* input_names, _In_ const OrtValue* const* input, size_t input_len, + _In_ const char* const* output_names, size_t output_names_len, _Out_ OrtValue** output); -ORT_API_STATUS(OrtInferenceSessionGetInputCount, _In_ const ONNXSession* sess, _Out_ size_t* out); -ORT_API_STATUS(OrtInferenceSessionGetOutputCount, _In_ const ONNXSession* sess, _Out_ size_t* out); +ORT_API_STATUS(OrtInferenceSessionGetInputCount, _In_ const OrtSession* sess, _Out_ size_t* out); +ORT_API_STATUS(OrtInferenceSessionGetOutputCount, _In_ const OrtSession* sess, _Out_ size_t* out); /** * \param out should be freed by OrtReleaseObject after use */ -ORT_API_STATUS(OrtInferenceSessionGetInputTypeInfo, _In_ const ONNXSession* sess, size_t index, _Out_ struct OrtTypeInfo** out); +ORT_API_STATUS(OrtInferenceSessionGetInputTypeInfo, _In_ const OrtSession* sess, size_t index, _Out_ OrtTypeInfo** out); /** * \param out should be freed by OrtReleaseObject after use */ -ORT_API_STATUS(OrtInferenceSessionGetOutputTypeInfo, _In_ const ONNXSession* sess, size_t index, _Out_ struct OrtTypeInfo** out); +ORT_API_STATUS(OrtInferenceSessionGetOutputTypeInfo, _In_ const OrtSession* sess, size_t index, _Out_ OrtTypeInfo** out); -ORT_API_STATUS(OrtInferenceSessionGetInputName, _In_ const ONNXSession* sess, size_t index, +ORT_API_STATUS(OrtInferenceSessionGetInputName, _In_ const OrtSession* sess, size_t index, _Inout_ OrtAllocator* allocator, _Out_ char** value); -ORT_API_STATUS(OrtInferenceSessionGetOutputName, _In_ const ONNXSession* sess, size_t index, +ORT_API_STATUS(OrtInferenceSessionGetOutputName, _In_ const OrtSession* sess, size_t index, _Inout_ OrtAllocator* allocator, _Out_ char** value); -ORT_API_STATUS(OrtTensorProtoToONNXValue, _Inout_ OrtAllocator* allocator, - _In_ const void* input, int input_len, _Out_ ONNXValue** out); +ORT_API_STATUS(OrtTensorProtoToOrtValue, _Inout_ OrtAllocator* allocator, + _In_ const void* input, int input_len, _Out_ OrtValue** out); /** * Deprecated. Please use OrtReleaseObject */ -ORT_API(void, ReleaseONNXEnv, OrtEnv* env); +ORT_API(void, OrtReleaseEnv, OrtEnv* env); #ifdef __cplusplus } diff --git a/include/onnxruntime/core/session/onnxruntime_cxx_api.h b/include/onnxruntime/core/session/onnxruntime_cxx_api.h index d9503688ee125..72ea38c995dbf 100644 --- a/include/onnxruntime/core/session/onnxruntime_cxx_api.h +++ b/include/onnxruntime/core/session/onnxruntime_cxx_api.h @@ -11,10 +11,10 @@ //TODO: encode error code in the message? #define ORT_THROW_ON_ERROR(expr) \ do { \ - ONNXStatus* onnx_status = (expr); \ + OrtStatus* onnx_status = (expr); \ if (onnx_status != nullptr) { \ std::string ort_error_message = OrtGetErrorMessage(onnx_status); \ - ReleaseONNXStatus(onnx_status); \ + OrtReleaseStatus(onnx_status); \ throw std::runtime_error(ort_error_message); \ } \ } while (0); @@ -29,7 +29,7 @@ template <> \ struct default_delete { \ void operator()(Ort##TYPE_NAME* ptr) { \ - (*reinterpret_cast(ptr))->Release(ptr); \ + (*reinterpret_cast(ptr))->Release(ptr); \ } \ }; \ } @@ -89,14 +89,14 @@ class SessionOptionsWrapper { return SessionOptionsWrapper(env_, p); } #ifdef _WIN32 - ONNXSession* OrtCreateInferenceSession(_In_ const wchar_t* model_path) { - ONNXSession* ret; + OrtSession* OrtCreateInferenceSession(_In_ const wchar_t* model_path) { + OrtSession* ret; ORT_THROW_ON_ERROR(::OrtCreateInferenceSession(env_, model_path, value.get(), &ret)); return ret; } #else - ONNXSession* OrtCreateInferenceSession(_In_ const char* model_path) { - ONNXSession* ret; + OrtSession* OrtCreateInferenceSession(_In_ const char* model_path) { + OrtSession* ret; ORT_THROW_ON_ERROR(::OrtCreateInferenceSession(env_, model_path, value.get(), &ret)); return ret; } @@ -105,15 +105,15 @@ class SessionOptionsWrapper { OrtAddCustomOp(value.get(), custom_op_path); } }; -inline ONNXValue* OrtCreateTensorAsONNXValue(_Inout_ OrtAllocator* env, const std::vector& shape, OrtTensorElementDataType type) { - ONNXValue* ret; - ORT_THROW_ON_ERROR(::OrtCreateTensorAsONNXValue(env, shape.data(), shape.size(), type, &ret)); +inline OrtValue* OrtCreateTensorAsOrtValue(_Inout_ OrtAllocator* env, const std::vector& shape, ONNXTensorElementDataType type) { + OrtValue* ret; + ORT_THROW_ON_ERROR(::OrtCreateTensorAsOrtValue(env, shape.data(), shape.size(), type, &ret)); return ret; } -inline ONNXValue* OrtCreateTensorWithDataAsONNXValue(_In_ const OrtAllocatorInfo* info, _In_ void* p_data, size_t p_data_len, const std::vector& shape, OrtTensorElementDataType type) { - ONNXValue* ret; - ORT_THROW_ON_ERROR(::OrtCreateTensorWithDataAsONNXValue(info, p_data, p_data_len, shape.data(), shape.size(), type, &ret)); +inline OrtValue* OrtCreateTensorWithDataAsOrtValue(_In_ const OrtAllocatorInfo* info, _In_ void* p_data, size_t p_data_len, const std::vector& shape, ONNXTensorElementDataType type) { + OrtValue* ret; + ORT_THROW_ON_ERROR(::OrtCreateTensorWithDataAsOrtValue(info, p_data, p_data_len, shape.data(), shape.size(), type, &ret)); return ret; } diff --git a/onnxruntime/core/framework/allocator.cc b/onnxruntime/core/framework/allocator.cc index ca9d5e158e183..26eaac40c7e64 100644 --- a/onnxruntime/core/framework/allocator.cc +++ b/onnxruntime/core/framework/allocator.cc @@ -36,7 +36,7 @@ ORT_API_STATUS_IMPL(OrtCreateAllocatorInfo, const char* name1, OrtAllocatorType return nullptr; } -ORT_API(void, ReleaseOrtAllocatorInfo, OrtAllocatorInfo* p) { +ORT_API(void, OrtReleaseAllocatorInfo, OrtAllocatorInfo* p) { delete p; } diff --git a/onnxruntime/core/framework/error_code.cc b/onnxruntime/core/framework/error_code.cc index 8513905034f43..87cff0ddbfffe 100644 --- a/onnxruntime/core/framework/error_code.cc +++ b/onnxruntime/core/framework/error_code.cc @@ -7,7 +7,7 @@ #include using onnxruntime::common::Status; -ORT_API(ONNXStatus*, CreateONNXStatus, OrtErrorCode code, const char* msg) { +ORT_API(OrtStatus*, OrtCreateStatus, OrtErrorCode code, const char* msg) { assert(!(code == 0 && msg != nullptr)); size_t clen = strlen(msg); size_t len = clen + 1 + sizeof(int); @@ -21,7 +21,7 @@ ORT_API(ONNXStatus*, CreateONNXStatus, OrtErrorCode code, const char* msg) { return ret; } namespace onnxruntime { -ONNXStatus* ToONNXStatus(const Status& st) { +OrtStatus* ToOrtStatus(const Status& st) { if (st.IsOK()) return nullptr; size_t clen = st.ErrorMessage().length(); @@ -36,10 +36,10 @@ ONNXStatus* ToONNXStatus(const Status& st) { return ret; } } // namespace onnxruntime -ORT_API(OrtErrorCode, OrtGetErrorCode, _In_ const ONNXStatus* status) { - return *reinterpret_cast(const_cast(status)); +ORT_API(OrtErrorCode, OrtGetErrorCode, _In_ const OrtStatus* status) { + return *reinterpret_cast(const_cast(status)); } -ORT_API(const char*, OrtGetErrorMessage, _In_ const ONNXStatus* status) { +ORT_API(const char*, OrtGetErrorMessage, _In_ const OrtStatus* status) { return reinterpret_cast(status) + sizeof(int); } diff --git a/onnxruntime/core/framework/error_code_helper.h b/onnxruntime/core/framework/error_code_helper.h index 9b75e7a138e50..90c02f5f7b3e4 100644 --- a/onnxruntime/core/framework/error_code_helper.h +++ b/onnxruntime/core/framework/error_code_helper.h @@ -6,5 +6,5 @@ #include "core/common/status.h" namespace onnxruntime { -ONNXStatus* ToONNXStatus(const onnxruntime::common::Status& st); +OrtStatus* ToOrtStatus(const onnxruntime::common::Status& st); }; diff --git a/onnxruntime/core/framework/onnx_object.cc b/onnxruntime/core/framework/onnx_object.cc index d7232e477c8d7..199b68dc5827b 100644 --- a/onnxruntime/core/framework/onnx_object.cc +++ b/onnxruntime/core/framework/onnx_object.cc @@ -5,17 +5,17 @@ #include ORT_API(uint32_t, OrtAddRefToObject, void* ptr) { - return (*static_cast(ptr))->AddRef(ptr); + return (*static_cast(ptr))->AddRef(ptr); } ORT_API(uint32_t, OrtReleaseObject, void* ptr) { if (ptr == nullptr) return 0; - return (*static_cast(ptr))->Release(ptr); + return (*static_cast(ptr))->Release(ptr); } namespace { struct ObjectImpl { - const ONNXObject* const cls; + const OrtObject* const cls; std::atomic_int ref_count; }; } // namespace diff --git a/onnxruntime/core/framework/onnxruntime_typeinfo.cc b/onnxruntime/core/framework/onnxruntime_typeinfo.cc index 0693daa2f4ff1..250d83e4dcac1 100644 --- a/onnxruntime/core/framework/onnxruntime_typeinfo.cc +++ b/onnxruntime/core/framework/onnxruntime_typeinfo.cc @@ -13,7 +13,7 @@ using onnxruntime::MLFloat16; using onnxruntime::Tensor; using onnxruntime::TensorShape; -OrtTypeInfo::OrtTypeInfo(OrtType type1, void* data1) noexcept : type(type1), data(data1) { +OrtTypeInfo::OrtTypeInfo(ONNXType type1, void* data1) noexcept : type(type1), data(data1) { } OrtTypeInfo::~OrtTypeInfo() { @@ -22,34 +22,34 @@ OrtTypeInfo::~OrtTypeInfo() { } ORT_API(const struct OrtTensorTypeAndShapeInfo*, OrtCastTypeInfoToTensorInfo, _In_ struct OrtTypeInfo* input) { - return input->type == ORT_TYPE_TENSOR ? reinterpret_cast(input->data) : nullptr; + return input->type == ONNX_TYPE_TENSOR ? reinterpret_cast(input->data) : nullptr; } -ONNXStatus* GetTensorShapeAndType(const TensorShape* shape, const onnxruntime::DataTypeImpl* tensor_data_type, OrtTensorTypeAndShapeInfo** out); +OrtStatus* GetTensorShapeAndType(const TensorShape* shape, const onnxruntime::DataTypeImpl* tensor_data_type, OrtTensorTypeAndShapeInfo** out); -ONNXStatus* OrtTypeInfo::FromDataTypeImpl(const onnxruntime::DataTypeImpl* input, const TensorShape* shape, const onnxruntime::DataTypeImpl* tensor_data_type, OrtTypeInfo** out) { +OrtStatus* OrtTypeInfo::FromDataTypeImpl(const onnxruntime::DataTypeImpl* input, const TensorShape* shape, const onnxruntime::DataTypeImpl* tensor_data_type, OrtTypeInfo** out) { if (input == nullptr) { - *out = new OrtTypeInfo(ORT_TYPE_UNKNOWN, nullptr); + *out = new OrtTypeInfo(ONNX_TYPE_UNKNOWN, nullptr); return nullptr; } if (input == DataTypeImpl::GetType()) { OrtTensorTypeAndShapeInfo* info = nullptr; if (tensor_data_type != nullptr) { - ONNXStatus* st = GetTensorShapeAndType(shape, tensor_data_type, &info); + OrtStatus* st = GetTensorShapeAndType(shape, tensor_data_type, &info); if (st != nullptr) return st; } - *out = new OrtTypeInfo(ORT_TYPE_TENSOR, info); + *out = new OrtTypeInfo(ONNX_TYPE_TENSOR, info); return nullptr; } if (input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType()) { - *out = new OrtTypeInfo(ORT_TYPE_MAP, nullptr); + *out = new OrtTypeInfo(ONNX_TYPE_MAP, nullptr); return nullptr; } if (input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType() || input == DataTypeImpl::GetType()) { - *out = new OrtTypeInfo(ORT_TYPE_SEQUENCE, nullptr); + *out = new OrtTypeInfo(ONNX_TYPE_SEQUENCE, nullptr); return nullptr; } - return CreateONNXStatus(ORT_NOT_IMPLEMENTED, "not implemented"); + return OrtCreateStatus(ORT_NOT_IMPLEMENTED, "not implemented"); } const DataTypeImpl* ElementTypeFromProto(ONNX_NAMESPACE::TensorProto_DataType type) { @@ -85,11 +85,11 @@ const DataTypeImpl* ElementTypeFromProto(ONNX_NAMESPACE::TensorProto_DataType ty } } -ONNXStatus* OrtTypeInfo::FromDataTypeImpl(const onnx::TypeProto* input, OrtTypeInfo** out) { +OrtStatus* OrtTypeInfo::FromDataTypeImpl(const onnx::TypeProto* input, OrtTypeInfo** out) { if (input->has_tensor_type()) { const ::onnx::TypeProto_Tensor& onnx_tensor_info = input->tensor_type(); const DataTypeImpl* type = ElementTypeFromProto(onnx_tensor_info.elem_type()); - ONNXStatus* st; + OrtStatus* st; OrtTensorTypeAndShapeInfo* info = nullptr; if (onnx_tensor_info.has_shape()) { const ::onnx::TensorShapeProto& s = onnx_tensor_info.shape(); @@ -104,24 +104,24 @@ ONNXStatus* OrtTypeInfo::FromDataTypeImpl(const onnx::TypeProto* input, OrtTypeI } if (st != nullptr) return st; - *out = new OrtTypeInfo(ORT_TYPE_TENSOR, info); + *out = new OrtTypeInfo(ONNX_TYPE_TENSOR, info); return nullptr; } if (input->has_sequence_type()) { - *out = new OrtTypeInfo(ORT_TYPE_SEQUENCE, nullptr); + *out = new OrtTypeInfo(ONNX_TYPE_SEQUENCE, nullptr); return nullptr; } if (input->has_map_type()) { - *out = new OrtTypeInfo(ORT_TYPE_MAP, nullptr); + *out = new OrtTypeInfo(ONNX_TYPE_MAP, nullptr); return nullptr; } if (input->has_opaque_type()) { - *out = new OrtTypeInfo(ORT_TYPE_OPAQUE, nullptr); + *out = new OrtTypeInfo(ONNX_TYPE_OPAQUE, nullptr); return nullptr; } if (input->has_sparse_tensor_type()) { - *out = new OrtTypeInfo(ORT_TYPE_SPARSETENSOR, nullptr); + *out = new OrtTypeInfo(ONNX_TYPE_SPARSETENSOR, nullptr); return nullptr; } - return CreateONNXStatus(ORT_NOT_IMPLEMENTED, "not implemented"); + return OrtCreateStatus(ORT_NOT_IMPLEMENTED, "not implemented"); } diff --git a/onnxruntime/core/framework/onnxruntime_typeinfo.h b/onnxruntime/core/framework/onnxruntime_typeinfo.h index 7c2f5331bc76c..9cbef90d24bde 100644 --- a/onnxruntime/core/framework/onnxruntime_typeinfo.h +++ b/onnxruntime/core/framework/onnxruntime_typeinfo.h @@ -22,17 +22,17 @@ struct OrtTypeInfo : public onnxruntime::ObjectBase { public: friend class onnxruntime::ObjectBase; - OrtType type = ORT_TYPE_UNKNOWN; + ONNXType type = ONNX_TYPE_UNKNOWN; //owned by this void* data = nullptr; OrtTypeInfo(const OrtTypeInfo& other) = delete; OrtTypeInfo& operator=(const OrtTypeInfo& other) = delete; - static ONNXStatus* FromDataTypeImpl(const onnxruntime::DataTypeImpl* input, const onnxruntime::TensorShape* shape, + static OrtStatus* FromDataTypeImpl(const onnxruntime::DataTypeImpl* input, const onnxruntime::TensorShape* shape, const onnxruntime::DataTypeImpl* tensor_data_type, OrtTypeInfo** out); - static ONNXStatus* FromDataTypeImpl(const onnx::TypeProto*, OrtTypeInfo** out); + static OrtStatus* FromDataTypeImpl(const onnx::TypeProto*, OrtTypeInfo** out); private: - OrtTypeInfo(OrtType type, void* data) noexcept; + OrtTypeInfo(ONNXType type, void* data) noexcept; ~OrtTypeInfo(); }; diff --git a/onnxruntime/core/framework/tensor_type_and_shape.cc b/onnxruntime/core/framework/tensor_type_and_shape.cc index 76f0c88957daa..eb22ef015c12e 100644 --- a/onnxruntime/core/framework/tensor_type_and_shape.cc +++ b/onnxruntime/core/framework/tensor_type_and_shape.cc @@ -18,7 +18,7 @@ struct OrtTensorTypeAndShapeInfo : public onnxruntime::ObjectBase; - OrtTensorElementDataType type = ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT; + ONNXTensorElementDataType type = ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT; onnxruntime::TensorShape shape; static OrtTensorTypeAndShapeInfo* Create() { @@ -39,14 +39,14 @@ struct OrtTensorTypeAndShapeInfo : public onnxruntime::ObjectBasetype = type; return nullptr; @@ -60,7 +60,7 @@ ORT_API_STATUS_IMPL(OrtSetDims, _In_ OrtTensorTypeAndShapeInfo* this_ptr, _In_ c API_IMPL_END } -ORT_API(enum OrtTensorElementDataType, OrtGetTensorElementType, _In_ const struct OrtTensorTypeAndShapeInfo* info) { +ORT_API(enum ONNXTensorElementDataType, OrtGetTensorElementType, _In_ const struct OrtTensorTypeAndShapeInfo* info) { return info->type; } @@ -76,12 +76,12 @@ ORT_API(int64_t, OrtGetTensorShapeElementCount, _In_ const OrtTensorTypeAndShape return this_ptr->shape.Size(); } -struct ONNXValue; +struct OrtValue; namespace { -inline OrtTensorElementDataType MLDataTypeToOnnxRuntimeTensorElementDataType( +inline ONNXTensorElementDataType MLDataTypeToOnnxRuntimeTensorElementDataType( const onnxruntime::DataTypeImpl* cpp_type) { - OrtTensorElementDataType type; + ONNXTensorElementDataType type; if (cpp_type == onnxruntime::DataTypeImpl::GetType()) { type = ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT; } else if (cpp_type == onnxruntime::DataTypeImpl::GetType()) { @@ -115,10 +115,10 @@ inline OrtTensorElementDataType MLDataTypeToOnnxRuntimeTensorElementDataType( } } // namespace -ONNXStatus* GetTensorShapeAndType(const onnxruntime::TensorShape* shape, const onnxruntime::DataTypeImpl* tensor_data_type, OrtTensorTypeAndShapeInfo** out) { - OrtTensorElementDataType type = MLDataTypeToOnnxRuntimeTensorElementDataType(tensor_data_type); +OrtStatus* GetTensorShapeAndType(const onnxruntime::TensorShape* shape, const onnxruntime::DataTypeImpl* tensor_data_type, OrtTensorTypeAndShapeInfo** out) { + ONNXTensorElementDataType type = MLDataTypeToOnnxRuntimeTensorElementDataType(tensor_data_type); if (ONNX_TENSOR_ELEMENT_DATA_TYPE_UNDEFINED == type) { - return CreateONNXStatus(ORT_FAIL, "Not implemented"); + return OrtCreateStatus(ORT_FAIL, "Not implemented"); } OrtTensorTypeAndShapeInfo* ret = OrtCreateTensorTypeAndShapeInfo(); auto status = OrtSetTensorElementType(ret, type); @@ -137,7 +137,7 @@ ONNXStatus* GetTensorShapeAndType(const onnxruntime::TensorShape* shape, const o return nullptr; } -ORT_API_STATUS_IMPL(OrtGetTensorShapeAndType, _In_ const ONNXValue* value, +ORT_API_STATUS_IMPL(OrtGetTensorShapeAndType, _In_ const OrtValue* value, _Out_ OrtTensorTypeAndShapeInfo** out) { API_IMPL_BEGIN auto v = reinterpret_cast(value); @@ -146,30 +146,30 @@ ORT_API_STATUS_IMPL(OrtGetTensorShapeAndType, _In_ const ONNXValue* value, API_IMPL_END } -ORT_API(enum OrtType, OrtGetValueType, _In_ const ONNXValue* value) { +ORT_API(enum ONNXType, OrtGetValueType, _In_ const OrtValue* value) { try { auto v = reinterpret_cast(value); onnxruntime::MLDataType type = v->Type(); OrtTypeInfo* out; - ONNXStatus* ptr = OrtTypeInfo::FromDataTypeImpl(type, nullptr, nullptr, &out); + OrtStatus* ptr = OrtTypeInfo::FromDataTypeImpl(type, nullptr, nullptr, &out); if (ptr != nullptr) { - ReleaseONNXStatus(ptr); - return ORT_TYPE_UNKNOWN; + OrtReleaseStatus(ptr); + return ONNX_TYPE_UNKNOWN; } - OrtType ret = out->type; + ONNXType ret = out->type; OrtReleaseObject(out); return ret; } catch (std::exception&) { - return ORT_TYPE_UNKNOWN; + return ONNX_TYPE_UNKNOWN; } } /** - * Get the type information of an ONNXValue + * Get the type information of an OrtValue * \param value * \return The returned value should be freed by OrtReleaseObject after use */ -ORT_API_STATUS_IMPL(OrtGetTypeInfo, _In_ const ONNXValue* value, struct OrtTypeInfo** out) { +ORT_API_STATUS_IMPL(OrtGetTypeInfo, _In_ const OrtValue* value, struct OrtTypeInfo** out) { auto v = reinterpret_cast(value); onnxruntime::MLDataType type = v->Type(); if (type == nullptr) { diff --git a/onnxruntime/core/providers/cpu/cpu_provider_factory.cc b/onnxruntime/core/providers/cpu/cpu_provider_factory.cc index 98813317834a1..dc8f9532bdd9c 100644 --- a/onnxruntime/core/providers/cpu/cpu_provider_factory.cc +++ b/onnxruntime/core/providers/cpu/cpu_provider_factory.cc @@ -15,7 +15,7 @@ struct CpuProviderFactory { CpuProviderFactory(); }; -ONNXStatus* ORT_API_CALL CreateCpu(void* this_, OrtProvider** out) { +OrtStatus* ORT_API_CALL CreateCpu(void* this_, OrtProvider** out) { CPUExecutionProviderInfo info; CpuProviderFactory* this_ptr = (CpuProviderFactory*)this_; info.create_arena = this_ptr->create_arena; diff --git a/onnxruntime/core/providers/cpu/symbols.txt b/onnxruntime/core/providers/cpu/symbols.txt index f60ba073a64bf..c7955f9b2beab 100644 --- a/onnxruntime/core/providers/cpu/symbols.txt +++ b/onnxruntime/core/providers/cpu/symbols.txt @@ -17,9 +17,9 @@ OrtCreateDefaultAllocator OrtCreateInferenceSession OrtCreateRunOptions OrtCreateSessionOptions -OrtCreateTensorAsONNXValue +OrtCreateTensorAsOrtValue OrtCreateTensorTypeAndShapeInfo -OrtCreateTensorWithDataAsONNXValue +OrtCreateTensorWithDataAsOrtValue OrtDisableCpuMemArena OrtDisableMemPattern OrtDisableProfiling @@ -50,7 +50,12 @@ OrtInferenceSessionGetOutputTypeInfo OrtInitialize OrtInitializeWithCustomLogger OrtIsTensor +OrtReleaseAllocatorInfo +OrtReleaseEnv OrtReleaseObject +OrtReleaseSession +OrtReleaseStatus +OrtReleaseValue OrtRunInference OrtRunOptionsGetRunLogVerbosityLevel OrtRunOptionsGetRunTag @@ -63,9 +68,4 @@ OrtSetSessionLogId OrtSetSessionLogVerbosityLevel OrtSetSessionThreadPoolSize OrtSetTensorElementType -OrtTensorProtoToONNXValue -ReleaseONNXEnv -ReleaseOrtAllocatorInfo -ReleaseONNXSession -ReleaseONNXStatus -ReleaseONNXValue +OrtTensorProtoToOrtValue diff --git a/onnxruntime/core/providers/cuda/cuda_provider_factory.cc b/onnxruntime/core/providers/cuda/cuda_provider_factory.cc index c9030b27c64ff..fb419ac9221d0 100644 --- a/onnxruntime/core/providers/cuda/cuda_provider_factory.cc +++ b/onnxruntime/core/providers/cuda/cuda_provider_factory.cc @@ -15,7 +15,7 @@ struct CUDAProviderFactory { CUDAProviderFactory(); }; -ONNXStatus* ORT_API_CALL CreateCuda(void* this_, OrtProvider** out) { +OrtStatus* ORT_API_CALL CreateCuda(void* this_, OrtProvider** out) { CUDAExecutionProviderInfo info; CUDAProviderFactory* this_ptr = (CUDAProviderFactory*)this_; info.device_id = this_ptr->device_id; diff --git a/onnxruntime/core/providers/mkldnn/mkldnn_provider_factory.cc b/onnxruntime/core/providers/mkldnn/mkldnn_provider_factory.cc index d9d9a543462b6..f9a7b0f063b94 100644 --- a/onnxruntime/core/providers/mkldnn/mkldnn_provider_factory.cc +++ b/onnxruntime/core/providers/mkldnn/mkldnn_provider_factory.cc @@ -15,7 +15,7 @@ struct MkldnnProviderFactory { MkldnnProviderFactory(); }; -ONNXStatus* ORT_API_CALL CreateMkldnn(void* this_, OrtProvider** out) { +OrtStatus* ORT_API_CALL CreateMkldnn(void* this_, OrtProvider** out) { MKLDNNExecutionProviderInfo info; MkldnnProviderFactory* this_ptr = (MkldnnProviderFactory*)this_; info.create_arena = this_ptr->create_arena; diff --git a/onnxruntime/core/session/default_cpu_allocator_c_api.cc b/onnxruntime/core/session/default_cpu_allocator_c_api.cc index 4267a7ce83cbe..8957fbdf4fe63 100644 --- a/onnxruntime/core/session/default_cpu_allocator_c_api.cc +++ b/onnxruntime/core/session/default_cpu_allocator_c_api.cc @@ -44,7 +44,7 @@ OrtDefaultAllocator() : ref_count_(1) { } ~OrtDefaultAllocator() { assert(ref_count_ == 0); - ReleaseOrtAllocatorInfo(cpuAllocatorInfo); + OrtReleaseAllocatorInfo(cpuAllocatorInfo); } public: @@ -71,7 +71,7 @@ ORT_ALLOCATOR_IMPL_END #define API_IMPL_END \ } \ catch (std::exception & ex) { \ - return CreateONNXStatus(ORT_RUNTIME_EXCEPTION, ex.what()); \ + return OrtCreateStatus(ORT_RUNTIME_EXCEPTION, ex.what()); \ } OrtAllocatorInterface OrtDefaultAllocator::table_ = { diff --git a/onnxruntime/core/session/onnxruntime_c_api.cc b/onnxruntime/core/session/onnxruntime_c_api.cc index fe3daab56735a..627821cb09b6b 100644 --- a/onnxruntime/core/session/onnxruntime_c_api.cc +++ b/onnxruntime/core/session/onnxruntime_c_api.cc @@ -35,7 +35,7 @@ using onnxruntime::MLStatus; using onnxruntime::MLValue; using onnxruntime::OutputDefList; using onnxruntime::Tensor; -using onnxruntime::ToONNXStatus; +using onnxruntime::ToOrtStatus; using onnxruntime::common::Status; #define ORT_API_RETURN_IF_ERROR(expr) \ @@ -65,10 +65,10 @@ struct OrtEnv : public onnxruntime::ObjectBase { }; #define API_IMPL_BEGIN try { -#define API_IMPL_END \ - } \ - catch (std::exception & ex) { \ - return CreateONNXStatus(ORT_RUNTIME_EXCEPTION, ex.what()); \ +#define API_IMPL_END \ + } \ + catch (std::exception & ex) { \ + return OrtCreateStatus(ORT_RUNTIME_EXCEPTION, ex.what()); \ } #define TENSOR_READ_API_BEGIN \ @@ -113,7 +113,7 @@ ORT_API_STATUS_IMPL(OrtInitializeWithCustomLogger, OrtLoggingFunction logging_fu Status status = Environment::Create(env); if (status.IsOK()) *out = new OrtEnv(env.release(), default_logging_manager.release()); - return ToONNXStatus(status); + return ToOrtStatus(status); API_IMPL_END } @@ -129,11 +129,11 @@ ORT_API_STATUS_IMPL(OrtInitialize, OrtLoggingLevel default_warning_level, Status status = Environment::Create(env); if (status.IsOK()) *out = new OrtEnv(env.release(), default_logging_manager.release()); - return ToONNXStatus(status); + return ToOrtStatus(status); API_IMPL_END } -ORT_API_STATUS_IMPL(OrtGetStringTensorDataLength, _In_ const ONNXValue* value, _Out_ size_t* out) { +ORT_API_STATUS_IMPL(OrtGetStringTensorDataLength, _In_ const OrtValue* value, _Out_ size_t* out) { TENSOR_READ_API_BEGIN const auto* src = tensor.Data(); int64_t len = tensor.Shape().Size(); @@ -144,17 +144,17 @@ ORT_API_STATUS_IMPL(OrtGetStringTensorDataLength, _In_ const ONNXValue* value, _ } *out = ret; } else - return CreateONNXStatus(ORT_INVALID_ARGUMENT, "shape is invalid"); + return OrtCreateStatus(ORT_INVALID_ARGUMENT, "shape is invalid"); return nullptr; API_IMPL_END } -ORT_API_STATUS_IMPL(OrtFillStringTensor, _In_ ONNXValue* value, _In_ const char* const* s, size_t s_len) { +ORT_API_STATUS_IMPL(OrtFillStringTensor, _In_ OrtValue* value, _In_ const char* const* s, size_t s_len) { TENSOR_READWRITE_API_BEGIN auto* dst = tensor->MutableData(); auto len = static_cast(tensor->Shape().Size()); if (s_len < len) { - return CreateONNXStatus(ORT_INVALID_ARGUMENT, "input array is too short"); + return OrtCreateStatus(ORT_INVALID_ARGUMENT, "input array is too short"); } for (size_t i = 0; i != len; ++i) { //allocate and copy @@ -165,8 +165,8 @@ ORT_API_STATUS_IMPL(OrtFillStringTensor, _In_ ONNXValue* value, _In_ const char* } template -ONNXStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, OrtAllocatorInterface** allocator, - std::unique_ptr* out) { +OrtStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, OrtAllocatorInterface** allocator, + std::unique_ptr* out) { size_t elem_count = 1; std::vector shapes(shape_len); for (size_t i = 0; i != shape_len; ++i) { @@ -176,11 +176,11 @@ ONNXStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, OrtAllocator size_t size_to_allocate; if (!IAllocator::CalcMemSizeForArray(sizeof(T), elem_count, &size_to_allocate)) { - return CreateONNXStatus(ORT_FAIL, "not enough memory"); + return OrtCreateStatus(ORT_FAIL, "not enough memory"); } void* p_data = (*allocator)->Alloc(allocator, size_to_allocate); if (p_data == nullptr) - return CreateONNXStatus(ORT_FAIL, "size overflow"); + return OrtCreateStatus(ORT_FAIL, "size overflow"); *out = std::make_unique(DataTypeImpl::GetType(), onnxruntime::TensorShape(shapes), static_cast(p_data), @@ -194,8 +194,8 @@ ONNXStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, OrtAllocator * this function will create a copy of the allocator info */ template -ONNXStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, const OrtAllocatorInfo* info, - void* p_data, size_t p_data_len, std::unique_ptr* out) { +OrtStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, const OrtAllocatorInfo* info, + void* p_data, size_t p_data_len, std::unique_ptr* out) { size_t elem_count = 1; std::vector shapes(shape_len); for (size_t i = 0; i != shape_len; ++i) { @@ -205,12 +205,12 @@ ONNXStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, const OrtAll size_t size_to_allocate; if (!IAllocator::CalcMemSizeForArray(sizeof(T), elem_count, &size_to_allocate)) { - return CreateONNXStatus(ORT_INVALID_ARGUMENT, "size overflow"); + return OrtCreateStatus(ORT_INVALID_ARGUMENT, "size overflow"); } if (size_to_allocate > p_data_len) { std::ostringstream oss; oss << "not enough space: expected " << size_to_allocate << ", got " << p_data_len; - return CreateONNXStatus(ORT_INVALID_ARGUMENT, oss.str().c_str()); + return OrtCreateStatus(ORT_INVALID_ARGUMENT, oss.str().c_str()); } *out = std::make_unique(DataTypeImpl::GetType(), onnxruntime::TensorShape(shapes), @@ -223,9 +223,9 @@ ONNXStatus* CreateTensorImpl(const size_t* shape, size_t shape_len, const OrtAll /** * this function will create a copy of the allocator info */ -ORT_API_STATUS_IMPL(OrtCreateTensorWithDataAsONNXValue, _In_ const OrtAllocatorInfo* info, +ORT_API_STATUS_IMPL(OrtCreateTensorWithDataAsOrtValue, _In_ const OrtAllocatorInfo* info, _In_ void* p_data, size_t p_data_len, _In_ const size_t* shape, size_t shape_len, - OrtTensorElementDataType type, _Out_ ONNXValue** out) { + ONNXTensorElementDataType type, _Out_ OrtValue** out) { API_IMPL_BEGIN std::unique_ptr tensor; switch (type) { @@ -274,21 +274,21 @@ ORT_API_STATUS_IMPL(OrtCreateTensorWithDataAsONNXValue, _In_ const OrtAllocatorI std::ostringstream oss; oss << "type " << type << " is not supported in this function"; std::string errmsg = oss.str(); - return CreateONNXStatus(ORT_NOT_IMPLEMENTED, errmsg.c_str()); + return OrtCreateStatus(ORT_NOT_IMPLEMENTED, errmsg.c_str()); } } std::unique_ptr value = std::make_unique(); value->Init(tensor.release(), DataTypeImpl::GetType(), DataTypeImpl::GetType()->GetDeleteFunc()); - *out = reinterpret_cast(value.release()); + *out = reinterpret_cast(value.release()); return nullptr; API_IMPL_END } -ORT_API_STATUS_IMPL(OrtCreateTensorAsONNXValue, _Inout_ OrtAllocator* allocator, - _In_ const size_t* shape, size_t shape_len, OrtTensorElementDataType type, - _Out_ ONNXValue** out) { +ORT_API_STATUS_IMPL(OrtCreateTensorAsOrtValue, _Inout_ OrtAllocator* allocator, + _In_ const size_t* shape, size_t shape_len, ONNXTensorElementDataType type, + _Out_ OrtValue** out) { API_IMPL_BEGIN std::unique_ptr tensor; switch (type) { @@ -338,34 +338,34 @@ ORT_API_STATUS_IMPL(OrtCreateTensorAsONNXValue, _Inout_ OrtAllocator* allocator, std::ostringstream oss; oss << "type " << type << " is not supported in this function"; std::string errmsg = oss.str(); - return CreateONNXStatus(ORT_NOT_IMPLEMENTED, errmsg.c_str()); + return OrtCreateStatus(ORT_NOT_IMPLEMENTED, errmsg.c_str()); } } std::unique_ptr value = std::make_unique(); value->Init(tensor.release(), DataTypeImpl::GetType(), DataTypeImpl::GetType()->GetDeleteFunc()); - *out = reinterpret_cast(value.release()); + *out = reinterpret_cast(value.release()); return nullptr; API_IMPL_END } template -static ONNXStatus* CreateInferenceSessionImpl(_In_ OrtEnv* env, _In_ T model_path, - _In_ const OrtSessionOptions* options, - _Out_ ONNXSession** out) { +static OrtStatus* CreateInferenceSessionImpl(_In_ OrtEnv* env, _In_ T model_path, + _In_ const OrtSessionOptions* options, + _Out_ OrtSession** out) { API_IMPL_BEGIN auto sess = std::make_unique<::onnxruntime::InferenceSession>(options == nullptr ? onnxruntime::SessionOptions() : options->value, env->loggingManager); Status status; if (options != nullptr && !options->custom_op_paths.empty()) { status = sess->LoadCustomOps(options->custom_op_paths); if (!status.IsOK()) - return ToONNXStatus(status); + return ToOrtStatus(status); } if (options != nullptr) for (OrtProviderFactoryInterface** p : options->provider_factories) { OrtProvider* provider; - ONNXStatus* error_code = (*p)->CreateProvider(p, &provider); + OrtStatus* error_code = (*p)->CreateProvider(p, &provider); if (error_code) return error_code; sess->RegisterExecutionProvider(std::unique_ptr( @@ -373,35 +373,35 @@ static ONNXStatus* CreateInferenceSessionImpl(_In_ OrtEnv* env, _In_ T model_pat } status = sess->Load(model_path); if (!status.IsOK()) - return ToONNXStatus(status); + return ToOrtStatus(status); status = sess->Initialize(); if (!status.IsOK()) - return ToONNXStatus(status); - *out = reinterpret_cast(sess.release()); + return ToOrtStatus(status); + *out = reinterpret_cast(sess.release()); return nullptr; API_IMPL_END } #ifdef _WIN32 ORT_API_STATUS_IMPL(OrtCreateInferenceSession, _In_ OrtEnv* env, _In_ const wchar_t* model_path, - _In_ const OrtSessionOptions* options, _Out_ ONNXSession** out) { + _In_ const OrtSessionOptions* options, _Out_ OrtSession** out) { API_IMPL_BEGIN return CreateInferenceSessionImpl(env, model_path, options, out); API_IMPL_END } #else ORT_API_STATUS_IMPL(OrtCreateInferenceSession, _In_ OrtEnv* env, _In_ const char* model_path, - _In_ const OrtSessionOptions* options, _Out_ ONNXSession** out) { + _In_ const OrtSessionOptions* options, _Out_ OrtSession** out) { API_IMPL_BEGIN return CreateInferenceSessionImpl(env, model_path, options, out); API_IMPL_END } #endif -ORT_API_STATUS_IMPL(OrtRunInference, _In_ ONNXSession* sess, +ORT_API_STATUS_IMPL(OrtRunInference, _In_ OrtSession* sess, _In_ OrtRunOptions* run_options, - _In_ const char* const* input_names, _In_ const ONNXValue* const* input, size_t input_len, - _In_ const char* const* output_names1, size_t output_names_len, _Out_ ONNXValue** output) { + _In_ const char* const* input_names, _In_ const OrtValue* const* input, size_t input_len, + _In_ const char* const* output_names1, size_t output_names_len, _Out_ OrtValue** output) { API_IMPL_BEGIN auto session = reinterpret_cast<::onnxruntime::InferenceSession*>(sess); ::onnxruntime::NameMLValMap in; @@ -410,7 +410,7 @@ ORT_API_STATUS_IMPL(OrtRunInference, _In_ ONNXSession* sess, auto kvp = in.insert(std::make_pair(std::string(input_names[i]), *reinterpret_cast(input[i]))); if (!kvp.second) { - return CreateONNXStatus(ORT_INVALID_ARGUMENT, "duplicated input name"); + return OrtCreateStatus(ORT_INVALID_ARGUMENT, "duplicated input name"); } ::onnxruntime::MLValue& value = kvp.first->second; if (value.Fence()) @@ -420,7 +420,7 @@ ORT_API_STATUS_IMPL(OrtRunInference, _In_ ONNXSession* sess, std::vector output_names(output_names_len); for (size_t i = 0; i != output_names_len; ++i) { if (output_names1[i] == nullptr || output_names1[i][0] == '\0') { - return CreateONNXStatus(ORT_INVALID_ARGUMENT, "output name cannot be empty"); + return OrtCreateStatus(ORT_INVALID_ARGUMENT, "output name cannot be empty"); } output_names[i] = output_names1[i]; } @@ -443,20 +443,20 @@ ORT_API_STATUS_IMPL(OrtRunInference, _In_ ONNXSession* sess, } if (!status.IsOK()) - return ToONNXStatus(status); + return ToOrtStatus(status); for (size_t i = 0; i != output_names_len; ++i) { ::onnxruntime::MLValue& value = fetches[i]; if (value.Fence()) value.Fence()->BeforeUsingAsInput(onnxruntime::kCpuExecutionProvider, queue_id); if (output[i] == nullptr) { - output[i] = reinterpret_cast(new MLValue(value)); + output[i] = reinterpret_cast(new MLValue(value)); } } return nullptr; API_IMPL_END } -ORT_API_STATUS_IMPL(OrtGetTensorMutableData, _In_ ONNXValue* value, _Out_ void** output) { +ORT_API_STATUS_IMPL(OrtGetTensorMutableData, _In_ OrtValue* value, _Out_ void** output) { TENSOR_READWRITE_API_BEGIN //TODO: test if it's a string tensor *output = tensor->MutableDataRaw(); @@ -464,13 +464,13 @@ ORT_API_STATUS_IMPL(OrtGetTensorMutableData, _In_ ONNXValue* value, _Out_ void** API_IMPL_END } -ORT_API_STATUS_IMPL(OrtGetStringTensorContent, _In_ const ONNXValue* value, +ORT_API_STATUS_IMPL(OrtGetStringTensorContent, _In_ const OrtValue* value, _Out_ void* s, size_t s_len, _Out_ size_t* offsets, size_t offsets_len) { TENSOR_READ_API_BEGIN const auto* input = tensor.Data(); auto len = static_cast(tensor.Shape().Size()); if (offsets_len < len) { - return CreateONNXStatus(ORT_FAIL, "space is not enough"); + return OrtCreateStatus(ORT_FAIL, "space is not enough"); } { size_t ret = 0; @@ -478,7 +478,7 @@ ORT_API_STATUS_IMPL(OrtGetStringTensorContent, _In_ const ONNXValue* value, ret += input[i].size(); } if (s_len < ret) { - return CreateONNXStatus(ORT_FAIL, "space is not enough"); + return OrtCreateStatus(ORT_FAIL, "space is not enough"); } } size_t f = 0; @@ -493,75 +493,75 @@ ORT_API_STATUS_IMPL(OrtGetStringTensorContent, _In_ const ONNXValue* value, API_IMPL_END } -ORT_API_STATUS_IMPL(OrtTensorProtoToONNXValue, _Inout_ OrtAllocator* allocator, - const void* input, int input_len, _Out_ ONNXValue** out) { +ORT_API_STATUS_IMPL(OrtTensorProtoToOrtValue, _Inout_ OrtAllocator* allocator, + const void* input, int input_len, _Out_ OrtValue** out) { API_IMPL_BEGIN std::shared_ptr allocator_ = std::make_shared(allocator); ::ONNX_NAMESPACE::TensorProto proto; if (!proto.ParseFromArray(input, input_len)) { - return CreateONNXStatus(ORT_FAIL, "parse input tensor proto failed"); + return OrtCreateStatus(ORT_FAIL, "parse input tensor proto failed"); } std::unique_ptr value = std::make_unique(); Status st = onnxruntime::utils::TensorProtoToMLValue(proto, allocator_, nullptr, 0, *value); if (!st.IsOK()) - return ToONNXStatus(st); - *out = reinterpret_cast(value.release()); + return ToOrtStatus(st); + *out = reinterpret_cast(value.release()); return nullptr; API_IMPL_END } -#define DEFINE_RELEASE_ONNX_RUNTIME_OBJECT_FUNCTION(INPUT_TYPE, REAL_TYPE) \ - ORT_API(void, Release##INPUT_TYPE, INPUT_TYPE* value) { \ - delete reinterpret_cast(value); \ +#define DEFINE_RELEASE_ORT_OBJECT_FUNCTION(INPUT_TYPE, REAL_TYPE) \ + ORT_API(void, OrtRelease##INPUT_TYPE, Ort##INPUT_TYPE* value) { \ + delete reinterpret_cast(value); \ } -#define DEFINE_RELEASE_ONNX_RUNTIME_OBJECT_FUNCTION_FOR_ARRAY(INPUT_TYPE, REAL_TYPE) \ - ORT_API(void, Release##INPUT_TYPE, INPUT_TYPE* value) { \ - delete[] reinterpret_cast(value); \ +#define DEFINE_RELEASE_ORT_OBJECT_FUNCTION_FOR_ARRAY(INPUT_TYPE, REAL_TYPE) \ + ORT_API(void, OrtRelease##INPUT_TYPE, Ort##INPUT_TYPE* value) { \ + delete[] reinterpret_cast(value); \ } -ORT_API_STATUS_IMPL(OrtInferenceSessionGetInputCount, _In_ const ONNXSession* sess, _Out_ size_t* out) { +ORT_API_STATUS_IMPL(OrtInferenceSessionGetInputCount, _In_ const OrtSession* sess, _Out_ size_t* out) { API_IMPL_BEGIN auto session = reinterpret_cast(sess); std::pair p = session->GetModelInputs(); if (!p.first.IsOK()) - return ToONNXStatus(p.first); + return ToOrtStatus(p.first); *out = p.second->size(); return nullptr; API_IMPL_END } -ORT_API_STATUS_IMPL(OrtInferenceSessionGetOutputCount, _In_ const ONNXSession* sess, _Out_ size_t* out) { +ORT_API_STATUS_IMPL(OrtInferenceSessionGetOutputCount, _In_ const OrtSession* sess, _Out_ size_t* out) { API_IMPL_BEGIN auto session = reinterpret_cast(sess); std::pair p = session->GetModelOutputs(); if (!p.first.IsOK()) - return ToONNXStatus(p.first); + return ToOrtStatus(p.first); *out = p.second->size(); return nullptr; API_IMPL_END } -ORT_API_STATUS_IMPL(OrtInferenceSessionGetInputTypeInfo, _In_ const ONNXSession* sess, size_t index, _Out_ struct OrtTypeInfo** out) { +ORT_API_STATUS_IMPL(OrtInferenceSessionGetInputTypeInfo, _In_ const OrtSession* sess, size_t index, _Out_ struct OrtTypeInfo** out) { API_IMPL_BEGIN auto session = reinterpret_cast(sess); std::pair p = session->GetModelInputs(); if (!p.first.IsOK()) - return ToONNXStatus(p.first); + return ToOrtStatus(p.first); if (p.second->size() <= index) - return CreateONNXStatus(ORT_FAIL, "out of index"); + return OrtCreateStatus(ORT_FAIL, "out of index"); const ONNX_NAMESPACE::TypeProto* type_proto = (*p.second)[index]->TypeAsProto(); return OrtTypeInfo::FromDataTypeImpl(type_proto, out); API_IMPL_END } -ORT_API_STATUS_IMPL(OrtInferenceSessionGetOutputTypeInfo, _In_ const ONNXSession* sess, size_t index, _Out_ struct OrtTypeInfo** out) { +ORT_API_STATUS_IMPL(OrtInferenceSessionGetOutputTypeInfo, _In_ const OrtSession* sess, size_t index, _Out_ struct OrtTypeInfo** out) { API_IMPL_BEGIN auto session = reinterpret_cast(sess); std::pair p = session->GetModelOutputs(); if (!p.first.IsOK()) - return ToONNXStatus(p.first); + return ToOrtStatus(p.first); if (p.second->size() <= index) - return CreateONNXStatus(ORT_FAIL, "out of index"); + return OrtCreateStatus(ORT_FAIL, "out of index"); const ONNX_NAMESPACE::TypeProto* type_proto = (*p.second)[index]->TypeAsProto(); return OrtTypeInfo::FromDataTypeImpl(type_proto, out); API_IMPL_END @@ -574,23 +574,23 @@ static char* StrDup(const std::string& str, OrtAllocator* allocator) { return output_string; } -static ONNXStatus* GetInputOutputNameImpl(_In_ const ONNXSession* sess, size_t index, - _Inout_ OrtAllocator* allocator, bool is_input, - _Out_ char** output) { +static OrtStatus* GetInputOutputNameImpl(_In_ const OrtSession* sess, size_t index, + _Inout_ OrtAllocator* allocator, bool is_input, + _Out_ char** output) { auto session = reinterpret_cast(sess); std::pair p = is_input ? session->GetModelInputs() : session->GetModelOutputs(); if (!p.first.IsOK()) - return ToONNXStatus(p.first); + return ToOrtStatus(p.first); if (p.second == nullptr) - return CreateONNXStatus(ORT_FAIL, "internal error"); + return OrtCreateStatus(ORT_FAIL, "internal error"); const InputDefList& defs = *p.second; if (index >= defs.size()) - return CreateONNXStatus(ORT_FAIL, "index out of range"); + return OrtCreateStatus(ORT_FAIL, "index out of range"); *output = StrDup(defs[index]->Name(), allocator); return nullptr; } -ORT_API(int, OrtIsTensor, _In_ const ONNXValue* value) { +ORT_API(int, OrtIsTensor, _In_ const OrtValue* value) { auto v = reinterpret_cast(value); return v->IsTensor() ? 1 : 0; } @@ -618,24 +618,24 @@ ORT_API(const struct OrtAllocatorInfo*, OrtAllocatorGetInfo, _In_ const OrtAlloc } } -ORT_API_STATUS_IMPL(OrtInferenceSessionGetInputName, _In_ const ONNXSession* sess, size_t index, +ORT_API_STATUS_IMPL(OrtInferenceSessionGetInputName, _In_ const OrtSession* sess, size_t index, _Inout_ OrtAllocator* allocator, _Out_ char** output) { API_IMPL_BEGIN return GetInputOutputNameImpl(sess, index, allocator, true, output); API_IMPL_END } -ORT_API_STATUS_IMPL(OrtInferenceSessionGetOutputName, _In_ const ONNXSession* sess, size_t index, +ORT_API_STATUS_IMPL(OrtInferenceSessionGetOutputName, _In_ const OrtSession* sess, size_t index, _Inout_ OrtAllocator* allocator, _Out_ char** output) { API_IMPL_BEGIN return GetInputOutputNameImpl(sess, index, allocator, false, output); API_IMPL_END } -DEFINE_RELEASE_ONNX_RUNTIME_OBJECT_FUNCTION(ONNXValue, MLValue) -DEFINE_RELEASE_ONNX_RUNTIME_OBJECT_FUNCTION(ONNXSession, ::onnxruntime::InferenceSession) -DEFINE_RELEASE_ONNX_RUNTIME_OBJECT_FUNCTION_FOR_ARRAY(ONNXStatus, char) +DEFINE_RELEASE_ORT_OBJECT_FUNCTION(Value, MLValue) +DEFINE_RELEASE_ORT_OBJECT_FUNCTION(Session, ::onnxruntime::InferenceSession) +DEFINE_RELEASE_ORT_OBJECT_FUNCTION_FOR_ARRAY(Status, char) -ORT_API(void, ReleaseONNXEnv, OrtEnv* env) { +ORT_API(void, OrtReleaseEnv, OrtEnv* env) { OrtReleaseObject(env); } diff --git a/onnxruntime/test/onnx/TestCase.cc b/onnxruntime/test/onnx/TestCase.cc index 7f7eb686ea39b..b323fa50c2f56 100644 --- a/onnxruntime/test/onnx/TestCase.cc +++ b/onnxruntime/test/onnx/TestCase.cc @@ -180,7 +180,7 @@ static Status SortTensorFileNames(std::vector> } Status LoopDataFile(int test_data_pb_fd, OrtAllocator* env, - const std::vector value_info, std::unordered_map& name_data_map, std::ostringstream& oss) { + const std::vector value_info, std::unordered_map& name_data_map, std::ostringstream& oss) { google::protobuf::io::FileInputStream f(test_data_pb_fd); f.SetCloseOnDelete(true); google::protobuf::io::CodedInputStream coded_input(&f); @@ -188,7 +188,7 @@ Status LoopDataFile(int test_data_pb_fd, OrtAllocator* env, Status st; int item_id = 1; for (proto::TraditionalMLData data; google::protobuf::util::ParseDelimitedFromCodedStream(&data, &coded_input, &clean_eof); ++item_id, data.Clear()) { - std::unique_ptr gvalue(nullptr, ReleaseONNXValue); + std::unique_ptr gvalue(nullptr, OrtReleaseValue); MLValue value; bool is_tensor = false; switch (data.values_case()) { @@ -223,9 +223,9 @@ Status LoopDataFile(int test_data_pb_fd, OrtAllocator* env, st = RichTypeProtoToMLValue(data.map_int64_to_double().v(), value); break; case proto::TraditionalMLData::kTensor: { - ONNXValue* temp_value; + OrtValue* temp_value; std::string s = data.tensor().SerializeAsString(); - ORT_THROW_ON_ERROR(OrtTensorProtoToONNXValue(env, s.data(), (int)s.size(), &temp_value)); + ORT_THROW_ON_ERROR(OrtTensorProtoToOrtValue(env, s.data(), (int)s.size(), &temp_value)); gvalue.reset(temp_value); is_tensor = true; } break; @@ -240,7 +240,7 @@ Status LoopDataFile(int test_data_pb_fd, OrtAllocator* env, if (value_name.empty()) value_name = value_info[name_data_map.size()].name(); - auto pv = name_data_map.insert(std::make_pair(value_name, is_tensor ? gvalue.release() : (ONNXValue*)new MLValue(value))); + auto pv = name_data_map.insert(std::make_pair(value_name, is_tensor ? gvalue.release() : (OrtValue*)new MLValue(value))); if (!pv.second) { st = Status(ONNXRUNTIME, FAIL, "duplicated test data name"); break; @@ -292,8 +292,8 @@ class OnnxTestCase : public ITestCase { } //If we cannot get input name from input_pbs, we'll use names like "data_0","data_1",... It's dirty hack // for https://github.com/onnx/onnx/issues/679 - ::onnxruntime::common::Status ConvertTestData(ONNXSession* session, const std::vector& test_data_pbs, - bool is_input, std::unordered_map& out); + ::onnxruntime::common::Status ConvertTestData(OrtSession* session, const std::vector& test_data_pbs, + bool is_input, std::unordered_map& out); std::string node_name_; std::once_flag model_parsed_; std::once_flag config_parsed_; @@ -333,7 +333,7 @@ class OnnxTestCase : public ITestCase { const std::string& GetTestCaseName() const override { return test_case_name_; } - ::onnxruntime::common::Status LoadTestData(ONNXSession* session, size_t id, std::unordered_map&, bool is_input) override; + ::onnxruntime::common::Status LoadTestData(OrtSession* session, size_t id, std::unordered_map&, bool is_input) override; }; Status OnnxTestCase::loadModelFile(const PATH_CHAR_TYPE* model_url, ONNX_NAMESPACE::ModelProto** model_pb) { @@ -463,7 +463,7 @@ static Status LoadTensors(const std::vector& pb_files, return Status::OK(); } -Status OnnxTestCase::LoadTestData(ONNXSession* session, size_t id, std::unordered_map& name_data_map, bool is_input) { +Status OnnxTestCase::LoadTestData(OrtSession* session, size_t id, std::unordered_map& name_data_map, bool is_input) { if (id >= test_data_dirs_.size()) return Status(ONNXRUNTIME, INVALID_ARGUMENT, "out of bound"); @@ -516,8 +516,8 @@ Status OnnxTestCase::LoadTestData(ONNXSession* session, size_t id, std::unordere return Status::OK(); } -Status OnnxTestCase::ConvertTestData(ONNXSession* session, const std::vector& test_data_pbs, - bool is_input, std::unordered_map& out) { +Status OnnxTestCase::ConvertTestData(OrtSession* session, const std::vector& test_data_pbs, + bool is_input, std::unordered_map& out) { bool has_valid_names = true; std::vector var_names(test_data_pbs.size()); for (size_t input_index = 0; input_index != test_data_pbs.size(); ++input_index) { @@ -553,8 +553,8 @@ Status OnnxTestCase::ConvertTestData(ONNXSession* session, const std::vector& name_data_map, bool is_input) = 0; + virtual ::onnxruntime::common::Status LoadTestData(OrtSession* session, size_t id, std::unordered_map& name_data_map, bool is_input) = 0; virtual const PATH_CHAR_TYPE* GetModelUrl() const = 0; virtual const std::string& GetTestCaseName() const = 0; //a string to help identify the dataset diff --git a/onnxruntime/test/onnx/main.cc b/onnxruntime/test/onnx/main.cc index 8f74bc5ea9a2d..00b3d0eaf0e45 100644 --- a/onnxruntime/test/onnx/main.cc +++ b/onnxruntime/test/onnx/main.cc @@ -162,10 +162,10 @@ int real_main(int argc, char* argv[]) { std::unique_ptr env; { OrtEnv* t; - ONNXStatus* ost = OrtInitialize(logging_level, "Default", &t); + OrtStatus* ost = OrtInitialize(logging_level, "Default", &t); if (ost != nullptr) { fprintf(stderr, "Error creating environment: %s \n", OrtGetErrorMessage(ost)); - ReleaseONNXStatus(ost); + OrtReleaseStatus(ost); return -1; } env.reset(t); @@ -176,10 +176,10 @@ int real_main(int argc, char* argv[]) { std::unique_ptr default_allocator; { OrtAllocator* p; - ONNXStatus* ost = OrtCreateDefaultAllocator(&p); + OrtStatus* ost = OrtCreateDefaultAllocator(&p); if (ost != nullptr) { fprintf(stderr, "Error creating environment: %s \n", OrtGetErrorMessage(ost)); - ReleaseONNXStatus(ost); + OrtReleaseStatus(ost); return -1; } default_allocator.reset(p); diff --git a/onnxruntime/test/onnx/runner.cc b/onnxruntime/test/onnx/runner.cc index 7fac9800f13c7..ad3bbfd032bbf 100644 --- a/onnxruntime/test/onnx/runner.cc +++ b/onnxruntime/test/onnx/runner.cc @@ -88,7 +88,7 @@ void PTestRunner::OnTaskFinished(size_t, EXECUTE_RESULT, ORT_CALLBACK_INSTANCE p } } -PTestRunner::PTestRunner(ONNXSession* session1, +PTestRunner::PTestRunner(OrtSession* session1, ITestCase* c, PThreadPool tpool, TestCaseCallBack on_finished1) : DataRunner(session1, c->GetTestCaseName(), c, on_finished1), next_test_to_run(0), finished(0), tpool_(tpool) { } @@ -282,12 +282,12 @@ std::vector LoadTests(const std::vectorGetTestCaseName(), c, on_finished1), repeat_count_(repeat_count) { } -DataRunner::DataRunner(ONNXSession* session1, const std::string& test_case_name1, ITestCase* c, TestCaseCallBack on_finished1) : test_case_name_(test_case_name1), c_(c), session(session1), on_finished(on_finished1), default_allocator(MockedOrtAllocator::Create()) { +DataRunner::DataRunner(OrtSession* session1, const std::string& test_case_name1, ITestCase* c, TestCaseCallBack on_finished1) : test_case_name_(test_case_name1), c_(c), session(session1), on_finished(on_finished1), default_allocator(MockedOrtAllocator::Create()) { std::string s; c->GetNodeName(&s); result = std::make_shared(c->GetDataCount(), EXECUTE_RESULT::UNKNOWN_ERROR, s); @@ -308,12 +308,12 @@ void DataRunner::RunTask(size_t task_id, ORT_CALLBACK_INSTANCE pci, bool store_r OnTaskFinished(task_id, res, pci); } -std::pair CompareGenericValue(const ONNXValue* o, const ONNXValue* expected_mlvalue, double per_sample_tolerance, double relative_per_sample_tolerance, +std::pair CompareGenericValue(const OrtValue* o, const OrtValue* expected_mlvalue, double per_sample_tolerance, double relative_per_sample_tolerance, bool post_processing) { return onnxruntime::CompareMLValue(*(MLValue*)o, *(MLValue*)expected_mlvalue, per_sample_tolerance, relative_per_sample_tolerance, post_processing); } EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { - std::unordered_map feeds; + std::unordered_map feeds; common::Status status = c_->LoadTestData(session, task_id, feeds, true); if (!status.IsOK()) { LOGF_DEFAULT(ERROR, "%s", status.ErrorMessage().c_str()); @@ -335,14 +335,14 @@ EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { TIME_SPEC start_time, end_time; GetMonotonicTimeCounter(&start_time); std::vector input_names(feeds.size()); - std::vector input_values(feeds.size()); + std::vector input_values(feeds.size()); size_t input_index = 0; for (auto& kvp : feeds) { input_names[input_index] = kvp.first.c_str(); input_values[input_index] = kvp.second; ++input_index; } - std::vector output_values(output_count); + std::vector output_values(output_count); { std::vector output_names_raw_ptr(output_count); for (size_t i = 0; i != output_count; ++i) { @@ -351,9 +351,9 @@ EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { auto onnx_status = OrtRunInference(session, nullptr, input_names.data(), input_values.data(), input_index, output_names_raw_ptr.data(), output_count, output_values.data()); if (onnx_status != nullptr) { std::string onnx_runtime_error_message = OrtGetErrorMessage(onnx_status); - ReleaseONNXStatus(onnx_status); + OrtReleaseStatus(onnx_status); for (auto& kvp : feeds) { - ReleaseONNXValue(kvp.second); + OrtReleaseValue(kvp.second); } throw std::runtime_error(onnx_runtime_error_message); } @@ -361,7 +361,7 @@ EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { GetMonotonicTimeCounter(&end_time); AccumulateTimeSpec(&spent_time_, &start_time, &end_time); for (auto& kvp : feeds) { - ReleaseONNXValue(kvp.second); + OrtReleaseValue(kvp.second); } if (!status.IsOK()) { LOGF_DEFAULT(ERROR, "%s:%s\n", test_case_name_.c_str(), status.ErrorMessage().c_str()); @@ -385,13 +385,13 @@ EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { } //TODO: if there are no output value files, just skip the validation - std::unordered_map expected_output_values; + std::unordered_map expected_output_values; status = c_->LoadTestData(session, task_id, expected_output_values, false); if (!status.IsOK()) { LOGF_DEFAULT(ERROR, "%s", status.ErrorMessage().c_str()); return StatusCodeToExecuteResult(status.Code()); } - std::unordered_map name_fetch_output_map; + std::unordered_map name_fetch_output_map; std::unordered_map name_output_value_info_proto; int i = 0; for (auto& output_name : output_names) { @@ -404,7 +404,7 @@ EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { EXECUTE_RESULT res = EXECUTE_RESULT::SUCCESS; for (auto& output : expected_output_values) { - ONNXValue* expected_output_value = output.second; + OrtValue* expected_output_value = output.second; const std::string& output_name = output.first; auto iter = name_fetch_output_map.find(output_name); if (iter == name_fetch_output_map.end()) { @@ -412,7 +412,7 @@ EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { LOGF_DEFAULT(ERROR, "cannot find %s in the outputs", output_name.c_str()); break; } - ONNXValue* actual_output_value = iter->second; + OrtValue* actual_output_value = iter->second; std::pair ret = CompareGenericValue(actual_output_value, expected_output_value, per_sample_tolerance, relative_per_sample_tolerance, post_procesing); COMPARE_RESULT compare_result = ret.first; if (compare_result == COMPARE_RESULT::SUCCESS) { @@ -461,10 +461,10 @@ EXECUTE_RESULT DataRunner::RunTaskImpl(size_t task_id) { } } for (auto& kvp : expected_output_values) { - ReleaseONNXValue(kvp.second); + OrtReleaseValue(kvp.second); } - for (ONNXValue* p : output_values) { - ReleaseONNXValue(p); + for (OrtValue* p : output_values) { + OrtReleaseValue(p); } return res; } @@ -492,8 +492,8 @@ void RunSingleTestCase(ITestCase* info, const onnxruntime::SessionOptionsWrapper } auto sf2 = sf.clone(); sf2.SetSessionLogId(info->GetTestCaseName().c_str()); - std::unique_ptr session_object( - sf2.OrtCreateInferenceSession(info->GetModelUrl()), ReleaseONNXSession); + std::unique_ptr session_object( + sf2.OrtCreateInferenceSession(info->GetModelUrl()), OrtReleaseSession); LOGF_DEFAULT(INFO, "testing %s\n", info->GetTestCaseName().c_str()); //temp hack. Because we have no resource control. We may not have enough memory to run this test in parallel if (info->GetTestCaseName() == "coreml_FNS-Candy_ImageNet") diff --git a/onnxruntime/test/onnx/runner.h b/onnxruntime/test/onnx/runner.h index 9691e52e3844b..f3dfd852cdf42 100644 --- a/onnxruntime/test/onnx/runner.h +++ b/onnxruntime/test/onnx/runner.h @@ -41,18 +41,18 @@ class DataRunner { ::onnxruntime::TIME_SPEC spent_time_; private: - ONNXSession* session; + OrtSession* session; CALL_BACK on_finished; OrtAllocatorInterface** const default_allocator; EXECUTE_RESULT RunTaskImpl(size_t task_id); ORT_DISALLOW_COPY_AND_ASSIGNMENT(DataRunner); public: - DataRunner(ONNXSession* session1, const std::string& test_case_name1, ITestCase* c, TestCaseCallBack on_finished1); + DataRunner(OrtSession* session1, const std::string& test_case_name1, ITestCase* c, TestCaseCallBack on_finished1); virtual void OnTaskFinished(size_t task_id, EXECUTE_RESULT res, ORT_CALLBACK_INSTANCE pci) noexcept = 0; void RunTask(size_t task_id, ORT_CALLBACK_INSTANCE pci, bool store_result); virtual ~DataRunner() { - ReleaseONNXSession(session); + OrtReleaseSession(session); OrtReleaseObject(default_allocator); } @@ -98,7 +98,7 @@ class SeqTestRunner : public DataRunner { size_t repeat_count_; public: - SeqTestRunner(ONNXSession* session1, + SeqTestRunner(OrtSession* session1, ITestCase* c, size_t repeat_count, TestCaseCallBack on_finished1); @@ -115,7 +115,7 @@ class PTestRunner : public DataRunner { public: void Start(ORT_CALLBACK_INSTANCE pci, size_t concurrent_runs) override; - PTestRunner(ONNXSession* session1, + PTestRunner(OrtSession* session1, ITestCase* c, PThreadPool tpool, TestCaseCallBack on_finished1); diff --git a/onnxruntime/test/onnxruntime_exec/Runtime.h b/onnxruntime/test/onnxruntime_exec/Runtime.h index bbf1aed93479f..b74ee583f19e7 100644 --- a/onnxruntime/test/onnxruntime_exec/Runtime.h +++ b/onnxruntime/test/onnxruntime_exec/Runtime.h @@ -273,7 +273,7 @@ class WinMLRuntime { ctensor = &output.Get(); ONNX_NAMESPACE::ValueInfoProto expected_output_info = (*outputMeta)[i]->ToProto(); - std::pair ret = VerifyValueInfo(expected_output_info, (ONNXValue*)&output); + std::pair ret = VerifyValueInfo(expected_output_info, (OrtValue*)&output); COMPARE_RESULT compare_result = ret.first; compare_result = ret.first; if (compare_result != COMPARE_RESULT::SUCCESS) { diff --git a/onnxruntime/test/shared_lib/fns_candy_style_transfer.c b/onnxruntime/test/shared_lib/fns_candy_style_transfer.c index b26bb4df91857..7aba00362f0ef 100644 --- a/onnxruntime/test/shared_lib/fns_candy_style_transfer.c +++ b/onnxruntime/test/shared_lib/fns_candy_style_transfer.c @@ -8,11 +8,11 @@ #define ORT_ABORT_ON_ERROR(expr) \ do { \ - ONNXStatus* onnx_status = (expr); \ + OrtStatus* onnx_status = (expr); \ if (onnx_status != NULL) { \ const char* msg = OrtGetErrorMessage(onnx_status); \ fprintf(stderr, "%s\n", msg); \ - ReleaseONNXStatus(onnx_status); \ + OrtReleaseStatus(onnx_status); \ abort(); \ } \ } while (0); @@ -94,7 +94,7 @@ static int read_png_file(const char* input_file, size_t* height, size_t* width, /** * \param tensor should be a float tensor in [N,C,H,W] format */ -static int write_tensor_to_png_file(ONNXValue* tensor, const char* output_file) { +static int write_tensor_to_png_file(OrtValue* tensor, const char* output_file) { struct OrtTensorTypeAndShapeInfo* shape_info; ORT_ABORT_ON_ERROR(OrtGetTensorShapeAndType(tensor, &shape_info)); size_t dim_count = OrtGetNumOfDimensions(shape_info); @@ -132,7 +132,7 @@ static void usage() { printf("usage: \n"); } -int run_inference(ONNXSession* session, const char* input_file, const char* output_file) { +int run_inference(OrtSession* session, const char* input_file, const char* output_file) { size_t input_height; size_t input_width; float* model_input; @@ -151,28 +151,28 @@ int run_inference(ONNXSession* session, const char* input_file, const char* outp const size_t input_shape_len = sizeof(input_shape) / sizeof(input_shape[0]); const size_t model_input_len = model_input_ele_count * sizeof(float); - ONNXValue* input_tensor = NULL; - ORT_ABORT_ON_ERROR(OrtCreateTensorWithDataAsONNXValue(allocator_info, model_input, model_input_len, input_shape, input_shape_len, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &input_tensor)); + OrtValue* input_tensor = NULL; + ORT_ABORT_ON_ERROR(OrtCreateTensorWithDataAsOrtValue(allocator_info, model_input, model_input_len, input_shape, input_shape_len, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &input_tensor)); assert(input_tensor != NULL); assert(OrtIsTensor(input_tensor) != 0); - ReleaseOrtAllocatorInfo(allocator_info); + OrtReleaseAllocatorInfo(allocator_info); const char* input_names[] = {"inputImage"}; const char* output_names[] = {"outputImage"}; - ONNXValue* output_tensor = NULL; - ORT_ABORT_ON_ERROR(OrtRunInference(session, NULL, input_names, (const ONNXValue* const*)&input_tensor, 1, output_names, 1, &output_tensor)); + OrtValue* output_tensor = NULL; + ORT_ABORT_ON_ERROR(OrtRunInference(session, NULL, input_names, (const OrtValue* const*)&input_tensor, 1, output_names, 1, &output_tensor)); assert(output_tensor != NULL); assert(OrtIsTensor(output_tensor) != 0); int ret = 0; if (write_tensor_to_png_file(output_tensor, output_file) != 0) { ret = -1; } - ReleaseONNXValue(output_tensor); - ReleaseONNXValue(input_tensor); + OrtReleaseValue(output_tensor); + OrtReleaseValue(input_tensor); free(model_input); return ret; } -void verify_input_output_count(ONNXSession* session) { +void verify_input_output_count(OrtSession* session) { size_t count; ORT_ABORT_ON_ERROR(OrtInferenceSessionGetInputCount(session, &count)); assert(count == 1); @@ -203,12 +203,12 @@ int main(int argc, char* argv[]) { #ifdef USE_CUDA enable_cuda(session_option); #endif - ONNXSession* session; + OrtSession* session; ORT_ABORT_ON_ERROR(OrtCreateInferenceSession(env, model_path, session_option, &session)); verify_input_output_count(session); int ret = run_inference(session, input_file, output_file); OrtReleaseObject(session_option); - ReleaseONNXSession(session); + OrtReleaseSession(session); OrtReleaseObject(env); if (ret != 0) { fprintf(stderr, "fail\n"); diff --git a/onnxruntime/test/shared_lib/test_allocator.cc b/onnxruntime/test/shared_lib/test_allocator.cc index ef4921d5996a9..ab97260e95c4a 100644 --- a/onnxruntime/test/shared_lib/test_allocator.cc +++ b/onnxruntime/test/shared_lib/test_allocator.cc @@ -13,8 +13,8 @@ TEST_F(CApiTest, allocation_info) { ORT_THROW_ON_ERROR(OrtCreateAllocatorInfo("Cpu", OrtArenaAllocator, 0, OrtMemTypeDefault, &info1)); ORT_THROW_ON_ERROR(OrtCreateCpuAllocatorInfo(OrtArenaAllocator, OrtMemTypeDefault, &info2)); ASSERT_EQ(0, OrtCompareAllocatorInfo(info1, info2)); - ReleaseOrtAllocatorInfo(info1); - ReleaseOrtAllocatorInfo(info2); + OrtReleaseAllocatorInfo(info1); + OrtReleaseAllocatorInfo(info2); } TEST_F(CApiTest, DefaultAllocator) { diff --git a/onnxruntime/test/shared_lib/test_inference.cc b/onnxruntime/test/shared_lib/test_inference.cc index b5d3c10fb9791..e1b2156bf9e9e 100644 --- a/onnxruntime/test/shared_lib/test_inference.cc +++ b/onnxruntime/test/shared_lib/test_inference.cc @@ -13,20 +13,20 @@ using namespace onnxruntime; -void RunSession(OrtAllocator* env, ONNXSession* session_object, +void RunSession(OrtAllocator* env, OrtSession* session_object, const std::vector& dims_x, const std::vector& values_x, const std::vector& dims_y, const std::vector& values_y) { - std::unique_ptr value_x(nullptr, ReleaseONNXValue); - std::vector inputs(1); - inputs[0] = OrtCreateTensorAsONNXValue(env, dims_x, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT); + std::unique_ptr value_x(nullptr, OrtReleaseValue); + std::vector inputs(1); + inputs[0] = OrtCreateTensorAsOrtValue(env, dims_x, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT); value_x.reset(inputs[0]); void* raw_data; ORT_THROW_ON_ERROR(OrtGetTensorMutableData(inputs[0], &raw_data)); memcpy(raw_data, values_x.data(), values_x.size() * sizeof(values_x[0])); std::vector input_names{"X"}; - ONNXValue* output_tensor = nullptr; + OrtValue* output_tensor = nullptr; const char* output_names[] = {"Y"}; ORT_THROW_ON_ERROR(OrtRunInference(session_object, NULL, input_names.data(), inputs.data(), inputs.size(), output_names, 1, &output_tensor)); ASSERT_NE(output_tensor, nullptr); @@ -50,7 +50,7 @@ void RunSession(OrtAllocator* env, ONNXSession* session_object, for (size_t i = 0; i != total_len; ++i) { ASSERT_EQ(values_y[i], f[i]); } - ReleaseONNXValue(output_tensor); + OrtReleaseValue(output_tensor); } template @@ -98,7 +98,7 @@ void TestInference(OrtEnv* env, T model_uri, if (custom_op) { sf.AddCustomOp("libonnxruntime_custom_op_shared_lib_test.so"); } - std::unique_ptr inference_session(sf.OrtCreateInferenceSession(model_uri), ReleaseONNXSession); + std::unique_ptr inference_session(sf.OrtCreateInferenceSession(model_uri), OrtReleaseSession); std::unique_ptr default_allocator(MockedOrtAllocator::Create()); // Now run RunSession(default_allocator.get(), inference_session.get(), dims_x, values_x, expected_dims_y, expected_values_y); @@ -147,10 +147,10 @@ TEST_F(CApiTest, DISABLED_custom_op) { #ifdef ORT_RUN_EXTERNAL_ONNX_TESTS TEST_F(CApiTest, create_session_without_session_option) { constexpr PATH_TYPE model_uri = TSTR("../models/opset8/test_squeezenet/model.onnx"); - ONNXSession* ret; + OrtSession* ret; ORT_THROW_ON_ERROR(::OrtCreateInferenceSession(env, model_uri, nullptr, &ret)); ASSERT_NE(nullptr, ret); - ReleaseONNXSession(ret); + OrtReleaseSession(ret); } #endif TEST_F(CApiTest, create_tensor) { @@ -158,8 +158,8 @@ TEST_F(CApiTest, create_tensor) { size_t expected_len = 2; std::unique_ptr default_allocator(MockedOrtAllocator::Create()); { - std::unique_ptr tensor( - OrtCreateTensorAsONNXValue(default_allocator.get(), {expected_len}, ONNX_TENSOR_ELEMENT_DATA_TYPE_STRING), ReleaseONNXValue); + std::unique_ptr tensor( + OrtCreateTensorAsOrtValue(default_allocator.get(), {expected_len}, ONNX_TENSOR_ELEMENT_DATA_TYPE_STRING), OrtReleaseValue); ORT_THROW_ON_ERROR(OrtFillStringTensor(tensor.get(), s, expected_len)); std::unique_ptr shape_info; { @@ -185,9 +185,9 @@ TEST_F(CApiTest, create_tensor_with_data) { OrtAllocatorInfo* info; ORT_THROW_ON_ERROR(OrtCreateAllocatorInfo("Cpu", OrtDeviceAllocator, 0, OrtMemTypeDefault, &info)); std::vector dims = {4}; - std::unique_ptr tensor( - OrtCreateTensorWithDataAsONNXValue(info, values, values_length * sizeof(float), dims, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT), ReleaseONNXValue); - ReleaseOrtAllocatorInfo(info); + std::unique_ptr tensor( + OrtCreateTensorWithDataAsOrtValue(info, values, values_length * sizeof(float), dims, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT), OrtReleaseValue); + OrtReleaseAllocatorInfo(info); void* new_pointer; ORT_THROW_ON_ERROR(OrtGetTensorMutableData(tensor.get(), &new_pointer)); ASSERT_EQ(new_pointer, values); diff --git a/onnxruntime/test/shared_lib/test_io_types.cc b/onnxruntime/test/shared_lib/test_io_types.cc index 60caf4f18c4c1..ceebc782c66aa 100644 --- a/onnxruntime/test/shared_lib/test_io_types.cc +++ b/onnxruntime/test/shared_lib/test_io_types.cc @@ -6,7 +6,7 @@ using namespace onnxruntime; -static void TestModelInfo(const ONNXSession* inference_session, bool is_input, const std::vector& dims) { +static void TestModelInfo(const OrtSession* inference_session, bool is_input, const std::vector& dims) { size_t input_count; if (is_input) { ORT_THROW_ON_ERROR(OrtInferenceSessionGetInputCount(inference_session, &input_count)); @@ -28,7 +28,7 @@ static void TestModelInfo(const ONNXSession* inference_session, bool is_input, c const OrtTensorTypeAndShapeInfo* p = OrtCastTypeInfoToTensorInfo(input_type_info.get()); ASSERT_NE(nullptr, p); - enum OrtTensorElementDataType ele_type = OrtGetTensorElementType(p); + enum ONNXTensorElementDataType ele_type = OrtGetTensorElementType(p); ASSERT_EQ(ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, ele_type); ASSERT_EQ(dims.size(), OrtGetNumOfDimensions(p)); std::vector real_dims(dims.size()); @@ -39,7 +39,7 @@ static void TestModelInfo(const ONNXSession* inference_session, bool is_input, c TEST_F(CApiTest, input_output_type_info) { SessionOptionsWrapper sf(env); constexpr PATH_TYPE model_uri = TSTR("../models/opset8/test_squeezenet/model.onnx"); - std::unique_ptr inference_session(sf.OrtCreateInferenceSession(model_uri), ReleaseONNXSession); + std::unique_ptr inference_session(sf.OrtCreateInferenceSession(model_uri), OrtReleaseSession); TestModelInfo(inference_session.get(), true, {1, 3, 224, 224}); TestModelInfo(inference_session.get(), false, {1, 1000, 1, 1}); } diff --git a/onnxruntime/test/util/compare_mlvalue.cc b/onnxruntime/test/util/compare_mlvalue.cc index e4604c1b0e51b..68bd04fbbfab9 100644 --- a/onnxruntime/test/util/compare_mlvalue.cc +++ b/onnxruntime/test/util/compare_mlvalue.cc @@ -18,7 +18,7 @@ using namespace onnxruntime; namespace { -OrtTensorElementDataType CApiElementTypeFromProto(ONNX_NAMESPACE::TensorProto_DataType type) { +ONNXTensorElementDataType CApiElementTypeFromProto(ONNX_NAMESPACE::TensorProto_DataType type) { switch (type) { CASE_TYPE(FLOAT) CASE_TYPE(UINT8) @@ -313,7 +313,7 @@ std::pair CompareMLValue(const MLValue& o, const ML per_sample_tolerance, relative_per_sample_tolerance, post_processing); } -std::pair VerifyValueInfo(const ONNX_NAMESPACE::ValueInfoProto& v, const ONNXValue* o) { +std::pair VerifyValueInfo(const ONNX_NAMESPACE::ValueInfoProto& v, const OrtValue* o) { if (!v.has_type()) return std::make_pair(COMPARE_RESULT::SUCCESS, ""); if (v.type().has_tensor_type()) { if (OrtIsTensor(o) == 0) { @@ -331,8 +331,8 @@ std::pair VerifyValueInfo(const ONNX_NAMESPACE::Val ORT_THROW_ON_ERROR(OrtGetTensorShapeAndType(o, &t1)); info.reset(t1); } - OrtTensorElementDataType real_type = OrtGetTensorElementType(info.get()); - OrtTensorElementDataType expected_type = CApiElementTypeFromProto(t.elem_type()); + ONNXTensorElementDataType real_type = OrtGetTensorElementType(info.get()); + ONNXTensorElementDataType expected_type = CApiElementTypeFromProto(t.elem_type()); if (real_type != expected_type) { return std::make_pair(COMPARE_RESULT::TYPE_MISMATCH, ""); } diff --git a/onnxruntime/test/util/include/test/compare_mlvalue.h b/onnxruntime/test/util/include/test/compare_mlvalue.h index 6dbabba1355d1..32024287a76d4 100644 --- a/onnxruntime/test/util/include/test/compare_mlvalue.h +++ b/onnxruntime/test/util/include/test/compare_mlvalue.h @@ -23,5 +23,5 @@ std::pair CompareMLValue(const MLValue& real, const double relative_per_sample_tolerance, bool post_processing); //verify if the 'value' matches the 'expected' ValueInfoProto. 'value' is a model output -std::pair VerifyValueInfo(const ONNX_NAMESPACE::ValueInfoProto& expected, const ONNXValue* value); +std::pair VerifyValueInfo(const ONNX_NAMESPACE::ValueInfoProto& expected, const OrtValue* value); } // namespace onnxruntime diff --git a/onnxruntime/test/util/include/test_allocator.h b/onnxruntime/test/util/include/test_allocator.h index 1ef5929e1d8b2..660320c901647 100644 --- a/onnxruntime/test/util/include/test_allocator.h +++ b/onnxruntime/test/util/include/test_allocator.h @@ -47,7 +47,7 @@ MockedOrtAllocator() : ref_count_(1), memory_inuse(0) { } ~MockedOrtAllocator() { assert(ref_count_ == 0); - ReleaseOrtAllocatorInfo(cpuAllocatorInfo); + OrtReleaseAllocatorInfo(cpuAllocatorInfo); } public: From ff1e35012cce2fe7f581fa93e30de0e2f0ce21f7 Mon Sep 17 00:00:00 2001 From: RyanUnderhill Date: Mon, 17 Dec 2018 18:44:30 -0800 Subject: [PATCH 2/3] Fix C# methods --- .../NamedOnnxValue.cs | 2 +- .../Microsoft.ML.OnnxRuntime/NativeMethods.cs | 84 +++++++++---------- 2 files changed, 43 insertions(+), 43 deletions(-) diff --git a/csharp/src/Microsoft.ML.OnnxRuntime/NamedOnnxValue.cs b/csharp/src/Microsoft.ML.OnnxRuntime/NamedOnnxValue.cs index 55b609be8cb11..19eb93e662555 100644 --- a/csharp/src/Microsoft.ML.OnnxRuntime/NamedOnnxValue.cs +++ b/csharp/src/Microsoft.ML.OnnxRuntime/NamedOnnxValue.cs @@ -161,7 +161,7 @@ out nativeElementType longShape[i] = (ulong)shape[i]; } - IntPtr status = NativeMethods.OrtCreateTensorWithDataAsONNXValue( + IntPtr status = NativeMethods.OrtCreateTensorWithDataAsOrtValue( NativeMemoryAllocatorInfo.DefaultInstance.Handle, dataBufferPointer, (ulong)(dataBufferLength), diff --git a/csharp/src/Microsoft.ML.OnnxRuntime/NativeMethods.cs b/csharp/src/Microsoft.ML.OnnxRuntime/NativeMethods.cs index 861e717168614..c668b7e905095 100644 --- a/csharp/src/Microsoft.ML.OnnxRuntime/NativeMethods.cs +++ b/csharp/src/Microsoft.ML.OnnxRuntime/NativeMethods.cs @@ -17,44 +17,44 @@ internal static class NativeMethods #region Runtime/Environment API [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /* ONNXStatus* */OrtInitialize( + public static extern IntPtr /* OrtStatus* */OrtInitialize( LogLevel default_warning_level, string logId, - out IntPtr /*(ONNXEnv*)*/ env); - // ReleaseONNXEnv should not be used + out IntPtr /*(OrtEnv*)*/ env); + // OrtReleaseEnv should not be used [DllImport(nativeLib, CharSet = charSet)] - public static extern void ReleaseONNXEnv(IntPtr /*(ONNXEnv*)*/ env); + public static extern void OrtReleaseEnv(IntPtr /*(OrtEnv*)*/ env); #endregion Runtime/Environment API #region Status API [DllImport(nativeLib, CharSet = charSet)] - public static extern ErrorCode OrtGetErrorCode(IntPtr /*(ONNXStatus*)*/status); + public static extern ErrorCode OrtGetErrorCode(IntPtr /*(OrtStatus*)*/status); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /* char* */OrtGetErrorMessage(IntPtr /* (ONNXStatus*) */status); + public static extern IntPtr /* char* */OrtGetErrorMessage(IntPtr /* (OrtStatus*) */status); // returns char*, need to convert to string by the caller. - // does not free the underlying ONNXStatus* + // does not free the underlying OrtStatus* [DllImport(nativeLib, CharSet = charSet)] - public static extern void ReleaseONNXStatus(IntPtr /*(ONNXStatus*)*/ statusPtr); + public static extern void OrtReleaseStatus(IntPtr /*(OrtStatus*)*/ statusPtr); #endregion Status API #region InferenceSession API [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /* ONNXStatus* */OrtCreateInferenceSession( - IntPtr /* (ONNXEnv*) */ environment, + public static extern IntPtr /* OrtStatus* */OrtCreateInferenceSession( + IntPtr /* (OrtEnv*) */ environment, [MarshalAs(UnmanagedType.LPWStr)]string modelPath, //the model path is consumed as a wchar* in the C-api IntPtr /* (OrtSessionOptions*) */sessopnOptions, out IntPtr /**/ session); [DllImport(nativeLib, CharSet = charSet)] public static extern IntPtr /*(ONNStatus*)*/ OrtRunInference( - IntPtr /*(ONNXSession*)*/ session, - IntPtr /*(ONNXSessionRunOptions*)*/ runOptions, // can be null to use the default options + IntPtr /*(OrtSession*)*/ session, + IntPtr /*(OrtSessionRunOptions*)*/ runOptions, // can be null to use the default options string[] inputNames, - IntPtr[] /* (ONNXValue*[])*/ inputValues, + IntPtr[] /* (OrtValue*[])*/ inputValues, ulong inputCount, /* TODO: size_t, make it portable for x86 arm */ string[] outputNames, ulong outputCount, /* TODO: size_t, make it portable for x86 and arm */ @@ -65,47 +65,47 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtInferenceSessionGetInputCount( - IntPtr /*(ONNXSession*)*/ session, + public static extern IntPtr /*(OrtStatus*)*/ OrtInferenceSessionGetInputCount( + IntPtr /*(OrtSession*)*/ session, out ulong /* TODO: size_t */ count); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtInferenceSessionGetOutputCount( - IntPtr /*(ONNXSession*)*/ session, + public static extern IntPtr /*(OrtStatus*)*/ OrtInferenceSessionGetOutputCount( + IntPtr /*(OrtSession*)*/ session, out ulong /*TODO: size_t port*/ count); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/OrtInferenceSessionGetInputName( - IntPtr /*(ONNXSession*)*/ session, + public static extern IntPtr /*(OrtStatus*)*/OrtInferenceSessionGetInputName( + IntPtr /*(OrtSession*)*/ session, ulong index, //TODO: port size_t IntPtr /*(OrtAllocator*)*/ allocator, out IntPtr /*(char**)*/name); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/OrtInferenceSessionGetOutputName( - IntPtr /*(ONNXSession*)*/ session, + public static extern IntPtr /*(OrtStatus*)*/OrtInferenceSessionGetOutputName( + IntPtr /*(OrtSession*)*/ session, ulong index, //TODO: port size_t IntPtr /*(OrtAllocator*)*/ allocator, out IntPtr /*(char**)*/name); // release the typeinfo using OrtReleaseObject [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/OrtInferenceSessionGetInputTypeInfo( - IntPtr /*(const ONNXSession*)*/ session, + public static extern IntPtr /*(OrtStatus*)*/OrtInferenceSessionGetInputTypeInfo( + IntPtr /*(const OrtSession*)*/ session, ulong index, //TODO: port for size_t out IntPtr /*(struct OrtTypeInfo**)*/ typeInfo); // release the typeinfo using OrtReleaseObject [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/OrtInferenceSessionGetOutputTypeInfo( - IntPtr /*(const ONNXSession*)*/ session, + public static extern IntPtr /*(OrtStatus*)*/OrtInferenceSessionGetOutputTypeInfo( + IntPtr /*(const OrtSession*)*/ session, ulong index, //TODO: port for size_t out IntPtr /* (struct OrtTypeInfo**)*/ typeInfo); [DllImport(nativeLib, CharSet = charSet)] - public static extern void ReleaseONNXSession(IntPtr /*(ONNXSession*)*/session); + public static extern void OrtReleaseSession(IntPtr /*(OrtSession*)*/session); #endregion InferenceSession API @@ -161,16 +161,16 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca public static extern void OrtSessionOptionsAppendExecutionProvider(IntPtr /*(OrtSessionOptions*)*/ options, IntPtr /* (OrtProviderFactoryPtr*)*/ factory); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtCreateCpuExecutionProviderFactory(int use_arena, out IntPtr /*(OrtProviderFactoryPtr*)*/ factory); + public static extern IntPtr /*(OrtStatus*)*/ OrtCreateCpuExecutionProviderFactory(int use_arena, out IntPtr /*(OrtProviderFactoryPtr*)*/ factory); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtCreateMkldnnExecutionProviderFactory(int use_arena, out IntPtr /*(OrtProviderFactoryPtr**)*/ factory); + public static extern IntPtr /*(OrtStatus*)*/ OrtCreateMkldnnExecutionProviderFactory(int use_arena, out IntPtr /*(OrtProviderFactoryPtr**)*/ factory); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtCreateCUDAExecutionProviderFactory(int device_id, out IntPtr /*(OrtProviderFactoryPtr**)*/ factory); + public static extern IntPtr /*(OrtStatus*)*/ OrtCreateCUDAExecutionProviderFactory(int device_id, out IntPtr /*(OrtProviderFactoryPtr**)*/ factory); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtCreateNupharExecutionProviderFactory(int device_id, string target_str, out IntPtr /*(OrtProviderFactoryPtr**)*/ factory); + public static extern IntPtr /*(OrtStatus*)*/ OrtCreateNupharExecutionProviderFactory(int device_id, string target_str, out IntPtr /*(OrtProviderFactoryPtr**)*/ factory); [DllImport(nativeLib, CharSet = charSet)] public static extern void OrtAddCustomOp(IntPtr /*(OrtSessionOptions*)*/ options, string custom_op_path); @@ -197,7 +197,7 @@ public enum MemoryType [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /* (ONNXStatus*)*/ OrtCreateAllocatorInfo( + public static extern IntPtr /* (OrtStatus*)*/ OrtCreateAllocatorInfo( IntPtr /*(const char*) */name, AllocatorType allocatorType, int identifier, @@ -205,9 +205,9 @@ public enum MemoryType out IntPtr /*(OrtAllocatorInfo*)*/ allocatorInfo // memory ownership transfered to caller ); - //ONNXRUNTIME_API_STATUS(OrtCreateCpuAllocatorInfo, enum OrtAllocatorType type, enum OrtMemType mem_type1, _Out_ OrtAllocatorInfo** out) + //ORT_API_STATUS(OrtCreateCpuAllocatorInfo, enum OrtAllocatorType type, enum OrtMemType mem_type1, _Out_ OrtAllocatorInfo** out) [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /* (ONNXStatus*)*/ OrtCreateCpuAllocatorInfo( + public static extern IntPtr /* (OrtStatus*)*/ OrtCreateCpuAllocatorInfo( AllocatorType allocatorType, MemoryType memoryType, out IntPtr /*(OrtAllocatorInfo*)*/ allocatorInfo @@ -217,7 +217,7 @@ public enum MemoryType public static extern void ReleaseOrtAllocatorInfo(IntPtr /*(OrtAllocatorInfo*)*/ allocatorInfo); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/OrtCreateDefaultAllocator(out IntPtr /*(OrtAllocator**)*/ allocator); + public static extern IntPtr /*(OrtStatus*)*/OrtCreateDefaultAllocator(out IntPtr /*(OrtAllocator**)*/ allocator); /// /// Releases/Unrefs any object, including the Allocator @@ -243,32 +243,32 @@ public enum MemoryType #region Tensor/OnnxValue API [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /* ONNXStatus */ OrtCreateTensorWithDataAsONNXValue( + public static extern IntPtr /* OrtStatus */ OrtCreateTensorWithDataAsOrtValue( IntPtr /* (const OrtAllocatorInfo*) */ allocatorInfo, IntPtr /* (void*) */dataBufferHandle, ulong dataLength, //size_t, TODO: make it portable for x86, arm ulong[] shape, //size_t* or size_t[], TODO: make it portable for x86, arm ulong shapeLength, //size_t, TODO: make it portable for x86, arm TensorElementType type, - out IntPtr /* ONNXValuePtr* */ outputValue); + out IntPtr /* OrtValue** */ outputValue); /// This function doesn't work with string tensor - /// this is a no-copy method whose pointer is only valid until the backing ONNXValuePtr is free'd. + /// this is a no-copy method whose pointer is only valid until the backing OrtValue* is free'd. [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtGetTensorMutableData(IntPtr /*(ONNXValue*)*/ value, out IntPtr /* (void**)*/ dataBufferHandle); + public static extern IntPtr /*(OrtStatus*)*/ OrtGetTensorMutableData(IntPtr /*(OrtValue*)*/ value, out IntPtr /* (void**)*/ dataBufferHandle); //[DllImport(nativeLib, CharSet = charSet)] - //public static extern IntPtr /*(ONNXStatus*)*/ OrtGetTensorShapeDimCount(IntPtr /*(ONNXValue*)*/ value, out ulong dimension); //size_t TODO: make it portable for x86, arm + //public static extern IntPtr /*(OrtStatus*)*/ OrtGetTensorShapeDimCount(IntPtr /*(OrtValue*)*/ value, out ulong dimension); //size_t TODO: make it portable for x86, arm //[DllImport(nativeLib, CharSet = charSet)] - //public static extern IntPtr /*(ONNXStatus*)*/ OrtGetTensorShapeElementCount(IntPtr /*(ONNXValue*)*/value, out ulong count); + //public static extern IntPtr /*(OrtStatus*)*/ OrtGetTensorShapeElementCount(IntPtr /*(OrtValue*)*/value, out ulong count); [DllImport(nativeLib, CharSet = charSet)] public static extern IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ OrtCastTypeInfoToTensorInfo(IntPtr /*(struct OrtTypeInfo*)*/ typeInfo); [DllImport(nativeLib, CharSet = charSet)] - public static extern IntPtr /*(ONNXStatus*)*/ OrtGetTensorShapeAndType(IntPtr /*(ONNXValue*)*/ value, out IntPtr /*(struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo); + public static extern IntPtr /*(OrtStatus*)*/ OrtGetTensorShapeAndType(IntPtr /*(OrtValue*)*/ value, out IntPtr /*(struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo); [DllImport(nativeLib, CharSet = charSet)] public static extern TensorElementType OrtGetTensorElementType(IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo); @@ -295,7 +295,7 @@ public static extern void OrtGetDimensions( public static extern long OrtGetTensorShapeElementCount(IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo); [DllImport(nativeLib, CharSet = charSet)] - public static extern void ReleaseONNXValue(IntPtr /*(ONNXValue*)*/ value); + public static extern void OrtReleaseValue(IntPtr /*(OrtValue*)*/ value); #endregion } //class NativeMethods From 94ad2df268e44bf05d04aa84a3eb036b1dd59683 Mon Sep 17 00:00:00 2001 From: RyanUnderhill Date: Mon, 17 Dec 2018 19:33:45 -0800 Subject: [PATCH 3/3] More C# fixes --- csharp/src/Microsoft.ML.OnnxRuntime/InferenceSession.cs | 8 ++++---- csharp/src/Microsoft.ML.OnnxRuntime/NativeApiStatus.cs | 2 +- .../Microsoft.ML.OnnxRuntime/NativeOnnxTensorMemory.cs | 2 +- csharp/src/Microsoft.ML.OnnxRuntime/OnnxRuntime.cs | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/csharp/src/Microsoft.ML.OnnxRuntime/InferenceSession.cs b/csharp/src/Microsoft.ML.OnnxRuntime/InferenceSession.cs index c3382f3d4b3dc..8973a982d1094 100644 --- a/csharp/src/Microsoft.ML.OnnxRuntime/InferenceSession.cs +++ b/csharp/src/Microsoft.ML.OnnxRuntime/InferenceSession.cs @@ -74,7 +74,7 @@ public InferenceSession(string modelPath, SessionOptions options) { if (_nativeHandle != IntPtr.Zero) { - NativeMethods.ReleaseONNXSession(_nativeHandle); + NativeMethods.OrtReleaseSession(_nativeHandle); _nativeHandle = IntPtr.Zero; } throw e; @@ -178,7 +178,7 @@ internal IReadOnlyCollection Run(IReadOnlyCollection Run(IReadOnlyCollection