in csharp/src/Microsoft.ML.OnnxRuntime/NativeMethods.shared.cs [447:1663]
public delegate IntPtr /* OrtStatus* */DOrtCreateTensorRTProviderOptions(
out IntPtr /*(OrtTensorRTProviderOptions**)*/ trtProviderOptionsInstance);
public static DOrtCreateTensorRTProviderOptions OrtCreateTensorRTProviderOptions;
/// <summary>
/// Updates native OrtTensorRTProviderOptions instance using given key/value pairs
/// </summary>
/// <param name="trtProviderOptionsInstance">native instance of OrtTensorRTProviderOptions</param>
/// <param name="providerOptionsKeys">configuration keys of OrtTensorRTProviderOptions</param>
/// <param name="providerOptionsValues">configuration values of OrtTensorRTProviderOptions</param>
/// <param name="numKeys">number of configuration keys</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtUpdateTensorRTProviderOptions(
IntPtr /*(OrtTensorRTProviderOptions*)*/ trtProviderOptionsInstance,
IntPtr[] /*(const char* const *)*/ providerOptionsKeys,
IntPtr[] /*(const char* const *)*/ providerOptionsValues,
UIntPtr /*(size_t)*/ numKeys);
public static DOrtUpdateTensorRTProviderOptions OrtUpdateTensorRTProviderOptions;
/// <summary>
/// Get native OrtTensorRTProviderOptionsV2 in serialized string
/// </summary>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="ptr">is a UTF-8 null terminated string allocated using 'allocator'</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtGetTensorRTProviderOptionsAsString(
IntPtr /*(OrtTensorRTProviderOptionsV2**)*/ trtProviderOptionsInstance,
IntPtr /*(OrtAllocator*)*/ allocator,
out IntPtr /*(char**)*/ptr);
public static DOrtGetTensorRTProviderOptionsAsString OrtGetTensorRTProviderOptionsAsString;
/// <summary>
/// Releases native OrtTensorRTProviderOptions instance
/// </summary>
/// <param name="trtProviderOptionsInstance">native instance of OrtTensorRTProviderOptions to be released</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseTensorRTProviderOptions(IntPtr /*(OrtTensorRTProviderOptions*)*/ trtProviderOptionsInstance);
public static DOrtReleaseTensorRTProviderOptions OrtReleaseTensorRTProviderOptions;
/// <summary>
/// Creates native OrtCUDAProviderOptions instance
/// </summary>
/// <param name="cudaProviderOptionsInstance">(output) native instance of OrtCUDAProviderOptions</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtCreateCUDAProviderOptions(
out IntPtr /*(OrtCUDAProviderOptions**)*/ cudaProviderOptionsInstance);
public static DOrtCreateCUDAProviderOptions OrtCreateCUDAProviderOptions;
/// <summary>
/// Updates native OrtCUDAProviderOptions instance using given key/value pairs
/// </summary>
/// <param name="cudaProviderOptionsInstance">native instance of OrtCUDAProviderOptions</param>
/// <param name="providerOptionsKeys">configuration keys of OrtCUDAProviderOptions</param>
/// <param name="providerOptionsValues">configuration values of OrtCUDAProviderOptions</param>
/// <param name="numKeys">number of configuration keys</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtUpdateCUDAProviderOptions(
IntPtr /*(OrtCUDAProviderOptions*)*/ cudaProviderOptionsInstance,
IntPtr[] /*(const char* const *)*/ providerOptionsKeys,
IntPtr[] /*(const char* const *)*/ providerOptionsValues,
UIntPtr /*(size_t)*/ numKeys);
public static DOrtUpdateCUDAProviderOptions OrtUpdateCUDAProviderOptions;
/// <summary>
/// Get native OrtCUDAProviderOptionsV2 in serialized string
/// </summary>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="ptr">is a UTF-8 null terminated string allocated using 'allocator'</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtGetCUDAProviderOptionsAsString(
IntPtr /*(OrtCUDAProviderOptionsV2**)*/ cudaProviderOptionsInstance,
IntPtr /*(OrtAllocator*)*/ allocator,
out IntPtr /*(char**)*/ptr);
public static DOrtGetCUDAProviderOptionsAsString OrtGetCUDAProviderOptionsAsString;
/// <summary>
/// Releases native OrtCUDAProviderOptions instance
/// </summary>
/// <param name="cudaProviderOptionsInstance">native instance of OrtCUDAProviderOptions to be released</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseCUDAProviderOptions(IntPtr /*(OrtCUDAProviderOptions*)*/ cudaProviderOptionsInstance);
public static DOrtReleaseCUDAProviderOptions OrtReleaseCUDAProviderOptions;
#endregion
#region Status API
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate ErrorCode DOrtGetErrorCode(IntPtr /*(OrtStatus*)*/status);
public static DOrtGetErrorCode OrtGetErrorCode;
// returns char*, need to convert to string by the caller.
// does not free the underlying OrtStatus*
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* char* */DOrtGetErrorMessage(IntPtr /* (OrtStatus*) */status);
public static DOrtGetErrorMessage OrtGetErrorMessage;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseStatus(IntPtr /*(OrtStatus*)*/ statusPtr);
public static DOrtReleaseStatus OrtReleaseStatus;
#endregion Status API
#region InferenceSession API
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtCreateSession(
IntPtr /* (OrtEnv*) */ environment,
//[MarshalAs(UnmanagedType.LPStr)]string modelPath
byte[] modelPath,
IntPtr /* (OrtSessionOptions*) */sessopnOptions,
out IntPtr /**/ session);
public static DOrtCreateSession OrtCreateSession;
/// <summary>
/// Creates an instance of OrtSession with provided parameters
/// </summary>
/// <param name="environment">Native OrtEnv instance</param>
/// <param name="modelPath">UTF-8 bytes corresponding to model string path</param>
/// <param name="sessionOptions">Native SessionOptions instance</param>
/// <param name="prepackedWeightsContainer">Native OrtPrepackedWeightsContainer instance</param>
/// <param name="session">(Output) Created native OrtSession instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtCreateSessionWithPrepackedWeightsContainer(
IntPtr /* (OrtEnv*) */ environment,
byte[] modelPath,
IntPtr /* (OrtSessionOptions*) */sessionOptions,
IntPtr /* (OrtPrepackedWeightsContainer*) */prepackedWeightsContainer,
out IntPtr /* (OrtSession**) */ session);
public static DOrtCreateSessionWithPrepackedWeightsContainer OrtCreateSessionWithPrepackedWeightsContainer;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtCreateSessionFromArray(
IntPtr /* (OrtEnv*) */ environment,
byte[] modelData,
UIntPtr modelSize,
IntPtr /* (OrtSessionOptions*) */ sessionOptions,
out IntPtr /**/ session);
public static DOrtCreateSessionFromArray OrtCreateSessionFromArray;
/// <summary>
/// Creates an instance of OrtSession with provided parameters
/// </summary>
/// <param name="environment">Native OrtEnv instance</param>
/// <param name="modelData">Byte array correspoonding to the model</param>
/// <param name="modelSize">Size of the model in bytes</param>
/// <param name="sessionOptions">Native SessionOptions instance</param>
/// <param name="prepackedWeightsContainer">Native OrtPrepackedWeightsContainer instance</param>
/// <param name="session">(Output) Created native OrtSession instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus* */DOrtCreateSessionFromArrayWithPrepackedWeightsContainer(
IntPtr /* (OrtEnv*) */ environment,
byte[] /* (void*) */ modelData,
UIntPtr /* (size_t) */ modelSize,
IntPtr /* (OrtSessionOptions*) */ sessionOptions,
IntPtr /* (OrtPrepackedWeightsContainer*) */prepackedWeightsContainer,
out IntPtr /* (OrtSession**) */ session);
public static DOrtCreateSessionFromArrayWithPrepackedWeightsContainer OrtCreateSessionFromArrayWithPrepackedWeightsContainer;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(ONNStatus*)*/ DOrtRun(
IntPtr /*(OrtSession*)*/ session,
IntPtr /*(OrtSessionRunOptions*)*/ runOptions, // can be null to use the default options
IntPtr[] inputNames,
IntPtr[] /* (OrtValue*[])*/ inputValues,
UIntPtr inputCount,
IntPtr[] outputNames,
UIntPtr outputCount,
IntPtr[] outputValues /* An array of output value pointers. Array must be allocated by the caller */
);
public static DOrtRun OrtRun;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(ONNStatus*)*/ DOrtRunWithBinding(
IntPtr /*(OrtSession*)*/ session,
IntPtr /*(OrtSessionRunOptions*)*/ runOptions, // can not be null
IntPtr /*(const OrtIoBinding*)*/ io_binding
);
public static DOrtRunWithBinding OrtRunWithBinding;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSessionGetInputCount(
IntPtr /*(OrtSession*)*/ session,
out UIntPtr count);
public static DOrtSessionGetInputCount OrtSessionGetInputCount;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSessionGetOutputCount(
IntPtr /*(OrtSession*)*/ session,
out UIntPtr count);
public static DOrtSessionGetOutputCount OrtSessionGetOutputCount;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSessionGetOverridableInitializerCount(
IntPtr /*(OrtSession*)*/ session,
out UIntPtr count);
public static DOrtSessionGetOverridableInitializerCount OrtSessionGetOverridableInitializerCount;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtSessionGetInputName(
IntPtr /*(OrtSession*)*/ session,
UIntPtr index,
IntPtr /*(OrtAllocator*)*/ allocator,
out IntPtr /*(char**)*/name);
public static DOrtSessionGetInputName OrtSessionGetInputName;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtSessionGetOutputName(
IntPtr /*(OrtSession*)*/ session,
UIntPtr index,
IntPtr /*(OrtAllocator*)*/ allocator,
out IntPtr /*(char**)*/name);
public static DOrtSessionGetOutputName OrtSessionGetOutputName;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtSessionEndProfiling(
IntPtr /*(const OrtSession*)*/ session,
IntPtr /*(OrtAllocator*)*/ allocator,
out IntPtr /*(char**)*/profile_file);
public static DOrtSessionEndProfiling OrtSessionEndProfiling;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtSessionGetOverridableInitializerName(
IntPtr /*(OrtSession*)*/ session,
UIntPtr index,
IntPtr /*(OrtAllocator*)*/ allocator,
out IntPtr /*(char**)*/name);
public static DOrtSessionGetOverridableInitializerName OrtSessionGetOverridableInitializerName;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtSessionGetInputTypeInfo(
IntPtr /*(const OrtSession*)*/ session,
UIntPtr index,
out IntPtr /*(struct OrtTypeInfo**)*/ typeInfo);
public static DOrtSessionGetInputTypeInfo OrtSessionGetInputTypeInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtSessionGetOutputTypeInfo(
IntPtr /*(const OrtSession*)*/ session,
UIntPtr index,
out IntPtr /* (struct OrtTypeInfo**)*/ typeInfo);
public static DOrtSessionGetOutputTypeInfo OrtSessionGetOutputTypeInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtSessionGetOverridableInitializerTypeInfo(
IntPtr /*(const OrtSession*)*/ session,
UIntPtr index,
out IntPtr /* (struct OrtTypeInfo**)*/ typeInfo);
public static DOrtSessionGetOverridableInitializerTypeInfo OrtSessionGetOverridableInitializerTypeInfo;
// release the typeinfo using OrtReleaseTypeInfo
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseTypeInfo(IntPtr /*(OrtTypeInfo*)*/session);
public static DOrtReleaseTypeInfo OrtReleaseTypeInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseSession(IntPtr /*(OrtSession*)*/session);
public static DOrtReleaseSession OrtReleaseSession;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSessionGetProfilingStartTimeNs(
IntPtr /*(const OrtSession*)*/ session,
out UIntPtr /*(ulong* out)*/ startTime);
public static DOrtSessionGetProfilingStartTimeNs OrtSessionGetProfilingStartTimeNs;
#endregion InferenceSession API
#region SessionOptions API
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCreateSessionOptions(out IntPtr /*(OrtSessionOptions**)*/ sessionOptions);
public static DOrtCreateSessionOptions OrtCreateSessionOptions;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseSessionOptions(IntPtr /*(OrtSessionOptions*)*/session);
public static DOrtReleaseSessionOptions OrtReleaseSessionOptions;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCloneSessionOptions(IntPtr /*(OrtSessionOptions*)*/ sessionOptions, out IntPtr /*(OrtSessionOptions**)*/ output);
public static DOrtCloneSessionOptions OrtCloneSessionOptions;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetSessionExecutionMode(IntPtr /*(OrtSessionOptions*)*/ options,
ExecutionMode execution_mode);
public static DOrtSetSessionExecutionMode OrtSetSessionExecutionMode;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetOptimizedModelFilePath(IntPtr /* OrtSessionOptions* */ options, byte[] optimizedModelFilepath);
public static DOrtSetOptimizedModelFilePath OrtSetOptimizedModelFilePath;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtEnableProfiling(IntPtr /* OrtSessionOptions* */ options, byte[] profilePathPrefix);
public static DOrtEnableProfiling OrtEnableProfiling;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtDisableProfiling(IntPtr /* OrtSessionOptions* */ options);
public static DOrtDisableProfiling OrtDisableProfiling;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtEnableMemPattern(IntPtr /* OrtSessionOptions* */ options);
public static DOrtEnableMemPattern OrtEnableMemPattern;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtDisableMemPattern(IntPtr /* OrtSessionOptions* */ options);
public static DOrtDisableMemPattern OrtDisableMemPattern;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtEnableCpuMemArena(IntPtr /* OrtSessionOptions* */ options);
public static DOrtEnableCpuMemArena OrtEnableCpuMemArena;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtDisableCpuMemArena(IntPtr /* OrtSessionOptions* */ options);
public static DOrtDisableCpuMemArena OrtDisableCpuMemArena;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetSessionLogId(IntPtr /* OrtSessionOptions* */ options, IntPtr /* const char* */logId);
public static DOrtSetSessionLogId OrtSetSessionLogId;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetSessionLogVerbosityLevel(IntPtr /* OrtSessionOptions* */ options, int sessionLogVerbosityLevel);
public static DOrtSetSessionLogVerbosityLevel OrtSetSessionLogVerbosityLevel;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetSessionLogSeverityLevel(IntPtr /* OrtSessionOptions* */ options, OrtLoggingLevel sessionLogSeverityLevel);
public static DOrtSetSessionLogSeverityLevel OrtSetSessionLogSeverityLevel;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetIntraOpNumThreads(IntPtr /* OrtSessionOptions* */ options, int intraOpNumThreads);
public static DOrtSetIntraOpNumThreads OrtSetIntraOpNumThreads;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetInterOpNumThreads(IntPtr /* OrtSessionOptions* */ options, int interOpNumThreads);
public static DOrtSetInterOpNumThreads OrtSetInterOpNumThreads;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetSessionGraphOptimizationLevel(IntPtr /* OrtSessionOptions* */ options, GraphOptimizationLevel graphOptimizationLevel);
public static DOrtSetSessionGraphOptimizationLevel OrtSetSessionGraphOptimizationLevel;
/// <summary>
/// Add session config entry
/// </summary>
/// <param name="options">Native SessionOptions instance</param>
/// <param name="configKey">Config key</param>
/// <param name="configValue">Config value</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtAddSessionConfigEntry(IntPtr /* OrtSessionOptions* */ options,
IntPtr /* const char* */configKey,
IntPtr /* const char* */ configValue);
public static DOrtAddSessionConfigEntry OrtAddSessionConfigEntry;
///**
// * The order of invocation indicates the preference order as well. In other words call this method
// * on your most preferred execution provider first followed by the less preferred ones.
// * Calling this API is optional in which case onnxruntime will use its internal CPU execution provider.
// */
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_CPU(IntPtr /*(OrtSessionOptions*) */ options, int use_arena);
#if __MOBILE__
#if __ANDROID__
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_Nnapi(IntPtr /*(OrtSessionOptions*)*/ options, uint nnapi_flags);
#endif
#if __IOS__
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_CoreML(IntPtr /*(OrtSessionOptions*)*/ options, uint coreml_flags);
#endif
#else
// on non-mobile platforms any of these EPs are possible
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_Dnnl(IntPtr /*(OrtSessionOptions*) */ options, int use_arena);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_CUDA(IntPtr /*(OrtSessionOptions*) */ options, int device_id);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_ROCM(IntPtr /*(OrtSessionOptions*) */ options, int device_id);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_DML(IntPtr /*(OrtSessionOptions*) */ options, int device_id);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_OpenVINO(IntPtr /*(OrtSessionOptions*)*/ options, IntPtr /*(const char*)*/ device_id);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_Tensorrt(IntPtr /*(OrtSessionOptions*)*/ options, int device_id);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_MIGraphX(IntPtr /*(OrtSessionOptions*)*/ options, int device_id);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_Nuphar(IntPtr /*(OrtSessionOptions*) */ options, int allow_unaligned_buffers, IntPtr /*(char char*)*/ settings);
[DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
public static extern IntPtr /*(OrtStatus*)*/ OrtSessionOptionsAppendExecutionProvider_Stvm(IntPtr /*(OrtSessionOptions*) */ options, IntPtr /*(char char*)*/ settings);
#endif
/// <summary>
/// Append a TensorRT EP instance (configured based on given provider options) to the native OrtSessionOptions instance
/// </summary>
/// <param name="options">Native OrtSessionOptions instance</param>
/// <param name="trtProviderOptions">Native OrtTensorRTProviderOptions instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DSessionOptionsAppendExecutionProvider_TensorRT(
IntPtr /*(OrtSessionOptions*)*/ options,
IntPtr /*(const OrtTensorRTProviderOptions*)*/ trtProviderOptions);
public static DSessionOptionsAppendExecutionProvider_TensorRT SessionOptionsAppendExecutionProvider_TensorRT;
/// <summary>
/// Append a TensorRT EP instance (configured based on given provider options) to the native OrtSessionOptions instance
/// </summary>
/// <param name="options">Native OrtSessionOptions instance</param>
/// <param name="trtProviderOptions">Native OrtTensorRTProviderOptionsV2 instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DSessionOptionsAppendExecutionProvider_TensorRT_V2(
IntPtr /*(OrtSessionOptions*)*/ options,
IntPtr /*(const OrtTensorRTProviderOptionsV2*)*/ trtProviderOptions);
public static DSessionOptionsAppendExecutionProvider_TensorRT_V2 SessionOptionsAppendExecutionProvider_TensorRT_V2;
/// <summary>
/// Append a CUDA EP instance (configured based on given provider options) to the native OrtSessionOptions instance
/// </summary>
/// <param name="options">Native OrtSessionOptions instance</param>
/// <param name="cudaProviderOptions">Native OrtCUDAProviderOptions instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DSessionOptionsAppendExecutionProvider_CUDA(
IntPtr /*(OrtSessionOptions*)*/ options,
IntPtr /*(const OrtCUDAProviderOptions*)*/ cudaProviderOptions);
public static DSessionOptionsAppendExecutionProvider_CUDA SessionOptionsAppendExecutionProvider_CUDA;
/// <summary>
/// Append a CUDA EP instance (configured based on given provider options) to the native OrtSessionOptions instance
/// </summary>
/// <param name="options">Native OrtSessionOptions instance</param>
/// <param name="cudaProviderOptions">Native OrtCUDAProviderOptionsV2 instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DSessionOptionsAppendExecutionProvider_CUDA_V2(
IntPtr /*(OrtSessionOptions*)*/ options,
IntPtr /*(const OrtCUDAProviderOptionsV2*)*/ cudaProviderOptions);
public static DSessionOptionsAppendExecutionProvider_CUDA_V2 SessionOptionsAppendExecutionProvider_CUDA_V2;
/// <summary>
/// Free Dimension override (by denotation)
/// </summary>
/// <param name="options">Native SessionOptions instance</param>
/// <param name="dimDenotation">Dimension denotation</param>
/// <param name="dimValue">Dimension value</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtAddFreeDimensionOverride(IntPtr /*(OrtSessionOptions*)*/ options,
IntPtr /*(const char*)*/ dimDenotation,
long dimValue);
public static DOrtAddFreeDimensionOverride OrtAddFreeDimensionOverride;
/// <summary>
/// Free Dimension override (by name)
/// </summary>
/// <param name="options">Native SessionOptions instance</param>
/// <param name="dimName">Dimension name</param>
/// <param name="dimValue">Dimension value</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtAddFreeDimensionOverrideByName(IntPtr /*(OrtSessionOptions*)*/ options,
IntPtr /*(const char*)*/ dimName,
long dimValue);
public static DOrtAddFreeDimensionOverrideByName OrtAddFreeDimensionOverrideByName;
/// <summary>
/// Register custom op library
/// </summary>
/// <param name="options">Native SessionOptions instance</param>
/// <param name="libraryPath">Library path</param>
/// <param name="libraryHandle">(out) Native library handle</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtRegisterCustomOpsLibrary(IntPtr /*(OrtSessionOptions*) */ options,
IntPtr /*(const char*)*/ libraryPath,
out IntPtr /*(void**)*/ libraryHandle);
public static DOrtRegisterCustomOpsLibrary OrtRegisterCustomOpsLibrary;
/// <summary>
/// Add initializer that is shared across Sessions using this SessionOptions (by denotation)
/// </summary>
/// <param name="options">Native SessionOptions instance</param>
/// <param name="name">Name of the initializer</param>
/// <param name="ortValue">Native OrtValue instnce</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtAddInitializer(IntPtr /*(OrtSessionOptions*)*/ options,
IntPtr /*(const char*)*/ name,
IntPtr /*(OrtValue*)*/ ortValue);
public static DOrtAddInitializer OrtAddInitializer;
#endregion
#region RunOptions API
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCreateRunOptions(out IntPtr /* OrtRunOptions** */ runOptions);
public static DOrtCreateRunOptions OrtCreateRunOptions;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseRunOptions(IntPtr /*(OrtRunOptions*)*/options);
public static DOrtReleaseRunOptions OrtReleaseRunOptions;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsSetRunLogVerbosityLevel(IntPtr /* OrtRunOptions* */ options, int value);
public static DOrtRunOptionsSetRunLogVerbosityLevel OrtRunOptionsSetRunLogVerbosityLevel;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsSetRunLogSeverityLevel(IntPtr /* OrtRunOptions* */ options, OrtLoggingLevel value);
public static DOrtRunOptionsSetRunLogSeverityLevel OrtRunOptionsSetRunLogSeverityLevel;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsSetRunTag(IntPtr /* OrtRunOptions* */ options, IntPtr /* const char* */ runTag);
public static DOrtRunOptionsSetRunTag OrtRunOptionsSetRunTag;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsGetRunLogVerbosityLevel(IntPtr /* OrtRunOptions* */ options, out int verbosityLevel);
public static DOrtRunOptionsGetRunLogVerbosityLevel OrtRunOptionsGetRunLogVerbosityLevel;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsGetRunLogSeverityLevel(IntPtr /* OrtRunOptions* */ options, out OrtLoggingLevel severityLevel);
public static DOrtRunOptionsGetRunLogSeverityLevel OrtRunOptionsGetRunLogSeverityLevel;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsGetRunTag(IntPtr /* const OrtRunOptions* */options, out IntPtr /* const char** */ runtag);
public static DOrtRunOptionsGetRunTag OrtRunOptionsGetRunTag;
// Set a flag so that any running OrtRun* calls that are using this instance of OrtRunOptions
// will exit as soon as possible if the flag is true.
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsSetTerminate(IntPtr /* OrtRunOptions* */ options);
public static DOrtRunOptionsSetTerminate OrtRunOptionsSetTerminate;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtRunOptionsUnsetTerminate(IntPtr /* OrtRunOptions* */ options);
public static DOrtRunOptionsUnsetTerminate OrtRunOptionsUnsetTerminate;
#endregion
#region Allocator/MemoryInfo API
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*)*/ DOrtCreateMemoryInfo(
IntPtr /*(const char*) */name,
OrtAllocatorType allocatorType,
int identifier,
OrtMemType memType,
out IntPtr /*(OrtMemoryInfo*)*/ allocatorInfo // memory ownership transfered to caller
);
public static DOrtCreateMemoryInfo OrtCreateMemoryInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*)*/ DOrtCreateCpuMemoryInfo(
OrtAllocatorType allocatorType,
OrtMemType memoryType,
out IntPtr /*(OrtMemoryInfo*)*/ allocatorInfo
);
public static DOrtCreateCpuMemoryInfo OrtCreateCpuMemoryInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseMemoryInfo(IntPtr /*(OrtMemoryInfo*)*/ allocatorInfo);
public static DOrtReleaseMemoryInfo OrtReleaseMemoryInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCompareMemoryInfo(
IntPtr /*(const OrtMemoryInfo*)*/ info1,
IntPtr /*(const OrtMemoryInfo*)*/ info2,
out int /*(int* out)*/ result);
public static DOrtCompareMemoryInfo OrtCompareMemoryInfo;
/**
* Do not free the returned value
*/
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtMemoryInfoGetName(IntPtr /*(const OrtMemoryInfo* ptr)*/ mem_info, out IntPtr /*(const char**)*/ name);
public static DOrtMemoryInfoGetName OrtMemoryInfoGetName;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtMemoryInfoGetId(IntPtr /*(const OrtMemoryInfo* ptr)*/ mem_info, out int /*(int* out)*/ id);
public static DOrtMemoryInfoGetId OrtMemoryInfoGetId;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtMemoryInfoGetMemType(
IntPtr /*(const OrtMemoryInfo* ptr)*/ mem_info,
out OrtMemType /*(OrtMemType*)*/ mem_type);
public static DOrtMemoryInfoGetMemType OrtMemoryInfoGetMemType;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtMemoryInfoGetType(
IntPtr /*(const OrtMemoryInfo* ptr)*/ mem_info,
out OrtAllocatorType /*(OrtAllocatorType*)*/ alloc_type
);
public static DOrtMemoryInfoGetType OrtMemoryInfoGetType;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtGetAllocatorWithDefaultOptions(out IntPtr /*(OrtAllocator**)*/ allocator);
public static DOrtGetAllocatorWithDefaultOptions OrtGetAllocatorWithDefaultOptions;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/DOrtAllocatorGetInfo(IntPtr /*(const OrtAllocator*)*/ ptr, out IntPtr /*(const struct OrtMemoryInfo**)*/info);
public static DOrtAllocatorGetInfo OrtAllocatorGetInfo;
/// <summary>
/// Create an instance of arena configuration which will be used to create an arena based allocator
/// See docs/C_API.md for details on what the following parameters mean and how to choose these values
/// </summary>
/// <param name="maxMemory">Maximum amount of memory the arena allocates</param>
/// <param name="arenaExtendStrategy">Strategy for arena expansion</param>
/// <param name="initialChunkSizeBytes">Size of the region that the arena allocates first</param>
/// <param name="maxDeadBytesPerChunk">Maximum amount of fragmentation allowed per chunk</param>
/// <returns>Pointer to a native OrtStatus instance indicating success/failure of config creation</returns>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCreateArenaCfg(UIntPtr /*(size_t)*/ maxMemory, int /*(int)*/ arenaExtendStrategy,
int /*(int)*/ initialChunkSizeBytes, int /*(int)*/ maxDeadBytesPerChunk,
out IntPtr /*(OrtArenaCfg**)*/ arenaCfg);
public static DOrtCreateArenaCfg OrtCreateArenaCfg;
/// <summary>
/// Destroy an instance of an arena configuration instance
/// </summary>
/// <param name="arenaCfg">arena configuration instance to be destroyed</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseArenaCfg(IntPtr /*(OrtArenaCfg*)*/ arenaCfg);
public static DOrtReleaseArenaCfg OrtReleaseArenaCfg;
/// <summary>
/// Create an instance of allocator according to mem_info
/// </summary>
/// <param name="session">Session that this allocator should be used with</param>
/// <param name="info">memory allocator specs</param>
/// <param name="allocator">out pointer to a new allocator instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCreateAllocator(IntPtr /*(const OrtSession*)*/ session, IntPtr /*(const OrtMemoryInfo*)*/ info, out IntPtr /*(OrtAllocator**)*/ allocator);
public static DOrtCreateAllocator OrtCreateAllocator;
/// <summary>
/// Destroy an instance of an allocator created by OrtCreateAllocator
/// </summary>
/// <param name="allocator">instance to be destroyed</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseAllocator(IntPtr /*(OrtAllocator*)*/ allocator);
public static DOrtReleaseAllocator OrtReleaseAllocator;
/// <summary>
/// Allocate a chunk of native memory
/// </summary>
/// <param name="allocator">allocator instance</param>
/// <param name="size">bytes to allocate</param>
/// <param name="p">out pointer to the allocated memory. Must be freed by OrtAllocatorFree</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr DOrtAllocatorAlloc(IntPtr /*(OrtAllocator*)*/ allocator, UIntPtr /*size_t*/ size, out IntPtr /*(void**)*/ p);
public static DOrtAllocatorAlloc OrtAllocatorAlloc;
/// <summary>
/// Release native memory allocated by an allocator
/// </summary>
/// <param name="allocator">allocator instance</param>
/// <param name="p">pointer to native memory allocated by the allocator instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr DOrtAllocatorFree(IntPtr /*(OrtAllocator*)*/ allocator, IntPtr /*(void*)*/ p);
public static DOrtAllocatorFree OrtAllocatorFree;
#endregion Allocator/MemoryInfo API
#region IoBinding API
/// <summary>
/// Create OrtIoBinding instance that is used to bind memory that is allocated
/// either by a 3rd party allocator or an ORT device allocator. Such memory should be wrapped by
/// a native OrtValue of Tensor type. By binding such named values you will direct ORT to read model inputs
/// and write model outputs to the supplied memory.
/// </summary>
/// <param name="session">session to create OrtIoBinding instance</param>
/// <param name="io_binding">out a new instance of OrtIoBinding</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtCreateIoBinding(IntPtr /*(const OrtSession*)*/ session, out IntPtr /*(OrtIoBinding)*/ io_binding);
public static DOrtCreateIoBinding OrtCreateIoBinding;
/// <summary>
/// Destroy OrtIoBinding instance created by OrtCreateIoBinding
/// </summary>
/// <param name="io_bidning">instance of OrtIoBinding</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseIoBinding(IntPtr /*(OrtIoBinding)*/ io_binding);
public static DOrtReleaseIoBinding OrtReleaseIoBinding;
/// <summary>
/// Bind OrtValue to the model input with the specified name
/// If binding with the specified name already exists, it will be replaced
/// </summary>
/// <param name="io_bidning">instance of OrtIoBinding</param>
/// <param name="name">model input name (utf-8)</param>
/// <param name="ort_value">OrtValue that is used for input (may wrap arbitrary memory).
/// The param instance is copied internally so this argument may be released.
/// </param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtBindInput(IntPtr /*(OrtIoBinding)*/ io_binding, IntPtr /*(const char*)*/ name, IntPtr /*const OrtValue**/ ort_value);
public static DOrtBindInput OrtBindInput;
/// <summary>
/// The API calls Sync() on all EP providers present. This blocks until the device has completed
/// all preceding requested tasks. This is necessary when memory synchronization is required.
/// For example, the memory bound to an input is likely to be on a different CUDA stream.
/// For some scenarios and devices this may be a no-op, use
/// your best judgment.
/// </summary>
/// <param name="io_binding">instance of OrtIoBinding</param>
/// <returns>An instance of OrtStatus or null</returns>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtSynchronizeBoundInputs(IntPtr /*(OrtIoBinding)*/ io_binding);
public static DOrtSynchronizeBoundInputs OrtSynchronizeBoundInputs;
/// <summary>
/// Bind OrtValue to the model output with the specified name
/// If binding with the specified name already exists, it will be replaced
/// </summary>
/// <param name="io_bidning">instance of OrtIoBinding</param>
/// <param name="name">model output name (utf-8)</param>
/// <param name="ort_value">OrtValue that is used for output (may wrap arbitrary memory).
/// The param instance is copied internally so this argument may be released.
/// </param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtBindOutput(IntPtr /*(OrtIoBinding)*/ io_binding, IntPtr /*(const char*) */ name, IntPtr /*const OrtValue**/ ort_value);
public static DOrtBindOutput OrtBindOutput;
/// <summary>
/// Bind a device to the model output with the specified name
/// This is useful when the OrtValue can not be allocated ahead of time
/// due to unknown dimensions.
/// </summary>
/// <param name="io_binding">Instance of OrtIoBinding</param>
/// <param name="name">UTF-8 zero terminated name</param>
/// <param name="mem_info">OrtMemoryInfo instance that contains device id. May be obtained from the device specific allocator instance</param>
/// <returns></returns>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtBindOutputToDevice(IntPtr /*(OrtIoBinding)*/ io_binding, IntPtr /*(const char*) */ name, IntPtr /* const OrtMemoryInfo */ mem_info);
public static DOrtBindOutputToDevice OrtBindOutputToDevice;
/// <summary>
/// The API calls Sync() on all EP providers present. This blocks until the device has completed
/// all preceding requested tasks. This is necessary when memory synchronization is required.
/// For some scenarios and devices this may be a no-op, use your best judgment.
/// </summary>
/// <param name="io_binding">instance of OrtIoBinding</param>
/// <returns>An instance of OrtStatus or null</returns>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtSynchronizeBoundOutputs(IntPtr /*(OrtIoBinding)*/ io_binding);
public static DOrtSynchronizeBoundOutputs OrtSynchronizeBoundOutputs;
/// <summary>
/// The function will return all bound output names in the order they were bound.
/// It is the same order that the output values will be returned after RunWithBinding() is used.
/// The function will allocate two native allocations using the allocator supplied.
/// The caller is responsible for deallocating both of the buffers using the same allocator.
/// You may use OrtMemoryAllocation disposable class to wrap those allocations.
/// </summary>
/// <param name="io_binding">instance of OrtIoBinding</param>
/// <param name="allocator">allocator to use for memory allocation</param>
/// <param name="buffer">a continuous buffer that contains all output names.
/// Names are not zero terminated use lengths to extract strings. This needs to be deallocated.</param>
/// <param name="lengths">A buffer that contains lengths (size_t) for each of the returned strings in order.
/// The buffer must be deallocated.</param>
/// <param name="count">this contains the count of names returned which is the number of elements in lengths.</param>
/// <returns></returns>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtGetBoundOutputNames(IntPtr /* (const OrtIoBinding*) */ io_binding, IntPtr /* OrtAllocator* */ allocator,
out IntPtr /* char** */ buffer, out IntPtr /* size_t** */ lengths, out UIntPtr count);
public static DOrtGetBoundOutputNames OrtGetBoundOutputNames;
/// <summary>
/// The function returns output values after the model has been run with RunWithBinding()
/// It returns a natively allocated buffer of OrtValue pointers. All of the OrtValues must be individually
/// released after no longer needed. You may use OrtValue disposable class to wrap the native handle and properly dispose it
/// in connection with DisposableList<T>. All values are returned in the same order as they were bound.
/// The buffer that contains OrtValues must deallocated using the same allocator that was specified as an argument.
/// You may use an instance OrtMemoryAllocation to properly dispose of the native memory.
/// </summary>
/// <param name="io_binding">instance of OrtIOBinding</param>
/// <param name="allocator">allocator to use to allocate output buffer</param>
/// <param name="ortvalues">allocated buffer that contains pointers (IntPtr) to individual OrtValue instances</param>
/// <param name="count">count of OrtValues returned</param>
/// <returns></returns>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus*/ DOrtGetBoundOutputValues(IntPtr /* (const OrtIoBinding*) */ io_binding, IntPtr /* OrtAllocator* */ allocator,
out IntPtr /* OrtValue** */ ortvalues, out UIntPtr count);
public static DOrtGetBoundOutputValues OrtGetBoundOutputValues;
/// <summary>
/// Clears Input bindings. This is a convenience method.
/// Releasing OrtIoBinding instance would clear all bound inputs.
/// </summary>
/// <param name="io_binding">instance of OrtIoBinding</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtClearBoundInputs(IntPtr /*(OrtIoBinding)*/ io_binding);
public static DOrtClearBoundInputs OrtClearBoundInputs;
/// <summary>
/// Clears Output bindings. This is a convenience method.
/// Releasing OrtIoBinding instance would clear all bound outputs.
/// </summary>
/// <param name="io_binding">instance of OrtIoBinding</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtClearBoundOutputs(IntPtr /*(OrtIoBinding)*/ io_binding);
public static DOrtClearBoundOutputs OrtClearBoundOutputs;
/// <summary>
/// Provides element-level access into a tensor.
/// </summary>
/// <param name="location_values">a pointer to an array of index values that specify an element's location in the tensor data blob</param>
/// <param name="location_values_count">length of location_values</param>
/// <param name="out">a pointer to the element specified by location_values</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtTensorAt(IntPtr /*(OrtIoBinding)*/ io_binding);
public static DOrtTensorAt OrtTensorAt;
/// <summary>
/// Creates an allocator instance and registers it with the env to enable
/// sharing between multiple sessions that use the same env instance.
/// Lifetime of the created allocator will be valid for the duration of the environment.
/// Returns an error if an allocator with the same OrtMemoryInfo is already registered.
/// <param name="env">Native OrtEnv instance</param>
/// <param name="memInfo">Native OrtMemoryInfo instance</param>
/// <param name="arenaCfg">Native OrtArenaCfg instance</param>
/// <retruns>A pointer to native ortStatus indicating success/failure</retruns>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCreateAndRegisterAllocator(IntPtr /*(OrtEnv*)*/ env,
IntPtr /*(const OrtMemoryInfo*)*/ memInfo,
IntPtr/*(const OrtArenaCfg*)*/ arenaCfg);
public static DOrtCreateAndRegisterAllocator OrtCreateAndRegisterAllocator;
/// <summary>
/// Set the language projection for collecting telemetry data when Env is created
/// </summary>
/// <param name="projection">the source projected language</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtSetLanguageProjection(IntPtr /* (OrtEnv*) */ environment, OrtLanguageProjection projection);
public static DOrtSetLanguageProjection OrtSetLanguageProjection;
#endregion IoBinding API
#region ModelMetadata API
/// <summary>
/// Gets the ModelMetadata associated with an InferenceSession
/// </summary>
/// <param name="session">instance of OrtSession</param>
/// <param name="modelMetadata">(output) instance of OrtModelMetadata</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtSessionGetModelMetadata(IntPtr /* (const OrtSession*) */ session, out IntPtr /* (OrtModelMetadata**) */ modelMetadata);
public static DOrtSessionGetModelMetadata OrtSessionGetModelMetadata;
/// <summary>
/// Gets the producer name associated with a ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="value">(output) producer name from the ModelMetadata instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataGetProducerName(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
IntPtr /* (OrtAllocator*) */ allocator, out IntPtr /* (char**) */ value);
public static DOrtModelMetadataGetProducerName OrtModelMetadataGetProducerName;
/// <summary>
/// Gets the graph name associated with a ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="value">(output) graph name from the ModelMetadata instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataGetGraphName(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
IntPtr /* (OrtAllocator*) */ allocator, out IntPtr /* (char**) */ value);
public static DOrtModelMetadataGetGraphName OrtModelMetadataGetGraphName;
/// <summary>
/// Gets the domain associated with a ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="value">(output) domain from the ModelMetadata instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataGetDomain(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
IntPtr /* (OrtAllocator*) */ allocator, out IntPtr /* (char**) */ value);
public static DOrtModelMetadataGetDomain OrtModelMetadataGetDomain;
/// <summary>
/// Gets the description associated with a ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="value">(output) description from the ModelMetadata instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataGetDescription(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
IntPtr /* (OrtAllocator*) */ allocator, out IntPtr /* (char**) */ value);
public static DOrtModelMetadataGetDescription OrtModelMetadataGetDescription;
/// <summary>
/// Gets the description associated with a ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="value">(output) graph description from the ModelMetadata instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataGetGraphDescription(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
IntPtr /* (OrtAllocator*) */ allocator, out IntPtr /* (char**) */ value);
public static DOrtModelMetadataGetGraphDescription OrtModelMetadataGetGraphDescription;
/// <summary>
/// Gets the version associated with a ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="value">(output) version from the ModelMetadata instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataGetVersion(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
out long /* (int64_t*) */ value);
public static DOrtModelMetadataGetVersion OrtModelMetadataGetVersion;
/// <summary>
/// Gets all the keys in the custom metadata map in the ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="keys">(output) all keys in the custom metadata map</param>
/// <param name="numKeys">(output) number of keys in the custom metadata map</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataGetCustomMetadataMapKeys(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
IntPtr /* (OrtAllocator*) */ allocator, out IntPtr /* (char***) */ keys, out long /* (int64_t*) */ numKeys);
public static DOrtModelMetadataGetCustomMetadataMapKeys OrtModelMetadataGetCustomMetadataMapKeys;
/// <summary>
/// Gets the value associated with the given key in custom metadata map in the ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
/// <param name="allocator">instance of OrtAllocator</param>
/// <param name="key">key in the custom metadata map</param>
/// <param name="value">(output) value for the key in the custom metadata map</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtModelMetadataLookupCustomMetadataMap(IntPtr /* (const OrtModelMetadata*) */ modelMetadata,
IntPtr /* (OrtAllocator*) */ allocator, IntPtr /* (const char*) */ key, out IntPtr /* (char**) */ value);
public static DOrtModelMetadataLookupCustomMetadataMap OrtModelMetadataLookupCustomMetadataMap;
/// <summary>
/// Frees ModelMetadata instance
/// </summary>
/// <param name="modelMetadata">instance of OrtModelMetadata</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseModelMetadata(IntPtr /*(OrtModelMetadata*)*/ modelMetadata);
public static DOrtReleaseModelMetadata OrtReleaseModelMetadata;
#endregion ModelMetadata API
#region Tensor/OnnxValue API
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetValue(IntPtr /*(OrtValue*)*/ value,
int index,
IntPtr /*(OrtAllocator*)*/ allocator,
out IntPtr /*(OrtValue**)*/ outputValue);
public static DOrtGetValue OrtGetValue;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetValueType(IntPtr /*(OrtValue*)*/ value, out IntPtr /*(OnnxValueType*)*/ onnxtype);
public static DOrtGetValueType OrtGetValueType;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetOnnxTypeFromTypeInfo(IntPtr /*(OrtTypeInfo*)*/ typeinfo, out IntPtr /*(OnnxValueType*)*/ onnxtype);
public static DOrtGetOnnxTypeFromTypeInfo OrtGetOnnxTypeFromTypeInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetValueCount(IntPtr /*(OrtValue*)*/ value, out IntPtr /*(size_t*)*/ count);
public static DOrtGetValueCount OrtGetValueCount;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetTypeInfo(IntPtr /*(OrtValue*)*/ value, IntPtr /*(OrtValue**)*/ typeInfo);
public static DOrtGetTypeInfo OrtGetTypeInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCreateTensorAsOrtValue(
IntPtr /*_Inout_ OrtAllocator* */ allocator,
long[] /*_In_ const int64_t* */ shape,
UIntPtr /*size_t*/ shape_len,
Tensors.TensorElementType type,
out IntPtr /* OrtValue** */ outputValue);
public static DOrtCreateTensorAsOrtValue OrtCreateTensorAsOrtValue;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* OrtStatus */ DOrtCreateTensorWithDataAsOrtValue(
IntPtr /* (const OrtMemoryInfo*) */ allocatorInfo,
IntPtr /* (void*) */dataBufferHandle,
UIntPtr dataLength,
long[] shape,
UIntPtr shapeLength,
Tensors.TensorElementType type,
out IntPtr /* OrtValue** */ outputValue);
public static DOrtCreateTensorWithDataAsOrtValue OrtCreateTensorWithDataAsOrtValue;
/// This function doesn't work with string tensor
/// this is a no-copy method whose pointer is only valid until the backing OrtValue* is free'd.
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetTensorMutableData(IntPtr /*(OrtValue*)*/ value, out IntPtr /* (void**)*/ dataBufferHandle);
public static DOrtGetTensorMutableData OrtGetTensorMutableData;
/// \param value A tensor created from OrtCreateTensor... function.
/// \param len total data length, not including the trailing '\0' chars.
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtFillStringTensor(
IntPtr /* OrtValue */ value,
IntPtr[] /* const char* const* */s,
UIntPtr /* size_t */ s_len);
public static DOrtFillStringTensor OrtFillStringTensor;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetStringTensorContent(
IntPtr /*(OrtValue*)*/ value,
IntPtr /*(void*)*/ dst_buffer,
UIntPtr dst_buffer_len,
IntPtr offsets,
UIntPtr offsets_len);
public static DOrtGetStringTensorContent OrtGetStringTensorContent;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetStringTensorDataLength(IntPtr /*(OrtValue*)*/ value,
out UIntPtr /*(size_t*)*/ len);
public static DOrtGetStringTensorDataLength OrtGetStringTensorDataLength;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/
DOrtCastTypeInfoToTensorInfo(IntPtr /*(struct OrtTypeInfo*)*/ typeInfo, out IntPtr /*(const struct OrtTensorTypeAndShapeInfo**)*/ typeAndShapeInfo);
public static DOrtCastTypeInfoToTensorInfo OrtCastTypeInfoToTensorInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetTensorTypeAndShape(IntPtr /*(OrtValue*)*/ value, out IntPtr /*(struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo);
public static DOrtGetTensorTypeAndShape OrtGetTensorTypeAndShape;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseTensorTypeAndShapeInfo(IntPtr /*(OrtTensorTypeAndShapeInfo*)*/ value);
public static DOrtReleaseTensorTypeAndShapeInfo OrtReleaseTensorTypeAndShapeInfo;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetTensorElementType(IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo, out IntPtr /*(TensorElementType*)*/ output);
public static DOrtGetTensorElementType OrtGetTensorElementType;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetDimensionsCount(IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo, out UIntPtr output);
public static DOrtGetDimensionsCount OrtGetDimensionsCount;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetDimensions(
IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo,
long[] dim_values,
UIntPtr dim_values_length);
public static DOrtGetDimensions OrtGetDimensions;
/**
* Get the symbolic dimension names for dimensions with a value of -1.
* Order and number of entries is the same as values returned by GetDimensions.
* The name may be empty for an unnamed symbolic dimension.
* e.g.
* If OrtGetDimensions returns [-1, -1, 2], OrtGetSymbolicDimensions would return an array with 3 entries.
* If the values returned were ['batch', '', ''] it would indicate that
* - the first dimension was a named symbolic dimension (-1 dim value and name in symbolic dimensions),
* - the second dimension was an unnamed symbolic dimension (-1 dim value and empty string),
* - the entry for the third dimension should be ignored as it is not a symbolic dimension (dim value >= 0).
*/
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetSymbolicDimensions(
IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo,
IntPtr[] dim_params, /* const char* values, converted to string by caller */
UIntPtr dim_params_length);
public static DOrtGetSymbolicDimensions OrtGetSymbolicDimensions;
/**
* How many elements does this tensor have.
* May return a negative value
* e.g.
* [] -> 1
* [1,3,4] -> 12
* [2,0,4] -> 0
* [-1,3,4] -> -1
*/
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtGetTensorShapeElementCount(IntPtr /*(const struct OrtTensorTypeAndShapeInfo*)*/ typeAndShapeInfo, out IntPtr /*(long*)*/ output);
public static DOrtGetTensorShapeElementCount OrtGetTensorShapeElementCount;
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleaseValue(IntPtr /*(OrtValue*)*/ value);
public static DOrtReleaseValue OrtReleaseValue;
#endregion
#region Misc API
/// <summary>
/// Queries all the execution providers supported in the native onnxruntime shared library
/// </summary>
/// <param name="providers">(output) all execution providers (strings) supported in the native onnxruntime shared library</param>
/// <param name="numProviders">(output) number of execution providers (strings)</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtGetAvailableProviders(out IntPtr /* (char***) */ providers, out int /* (int*) */ numProviders);
public static DOrtGetAvailableProviders OrtGetAvailableProviders;
/// <summary>
/// Releases all execution provider strings allocated and returned by OrtGetAvailableProviders
/// </summary>
/// <param name="providers">all execution providers (strings) returned by OrtGetAvailableProviders</param>
/// <param name="numProviders">number of execution providers (strings)</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /* (OrtStatus*) */ DOrtReleaseAvailableProviders(IntPtr /* (char**) */ providers, int /* (int) */ numProviders);
public static DOrtReleaseAvailableProviders OrtReleaseAvailableProviders;
/// <summary>
/// Create an instance of PrepackedWeightsContainer
/// </summary>
/// <param name="prepackedWeightsContainer">(output) Created native OrtPrepackedWeightsContainer instance</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate IntPtr /*(OrtStatus*)*/ DOrtCreatePrepackedWeightsContainer(out IntPtr /*(OrtPrepackedWeightsContainer**)*/ prepackedWeightsContainer);
public static DOrtCreatePrepackedWeightsContainer OrtCreatePrepackedWeightsContainer;
/// <summary>
/// Destroy an instance of PrepackedWeightsContainer
/// </summary>
/// <param name="prepackedWeightsContainer">Native OrtPrepackedWeightsContainer instance to be destroyed</param>
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void DOrtReleasePrepackedWeightsContainer(IntPtr /*(OrtPrepackedWeightsContainer*)*/ prepackedWeightsContainer);
public static DOrtReleasePrepackedWeightsContainer OrtReleasePrepackedWeightsContainer;
#endregion
public static byte[] GetPlatformSerializedString(string str)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
return System.Text.Encoding.Unicode.GetBytes(str + Char.MinValue);
else
return System.Text.Encoding.UTF8.GetBytes(str + Char.MinValue);
}