com.github.asus4.onnxruntime 0.1.14 → 0.2.1

package/Plugins/iOS~/onnxruntime.xcframework/macos-arm64_x86_64/onnxruntime.framework/{Headers → Versions/A/Headers}/onnxruntime_run_options_config_keys.h

@@ -30,3 +30,22 @@ static const char* const kOrtRunOptionsConfigEnableMemoryArenaShrinkage = "memor
 // Per default it will be set to '0'
 // Taking CUDA EP as an example, it omit triggering cudaStreamSynchronize on the compute stream.
 static const char* const kOrtRunOptionsConfigDisableSynchronizeExecutionProviders = "disable_synchronize_execution_providers";
+
+// Set HTP performance mode for QNN HTP backend before session run.
+// options for HTP performance mode: "burst", "balanced", "default", "high_performance",
+// "high_power_saver", "low_balanced", "extreme_power_saver", "low_power_saver", "power_saver",
+// "sustained_high_performance". Default to "default".
+static const char* const kOrtRunOptionsConfigQnnPerfMode = "qnn.htp_perf_mode";
+
+// Set HTP performance mode for QNN HTP backend post session run.
+static const char* const kOrtRunOptionsConfigQnnPerfModePostRun = "qnn.htp_perf_mode_post_run";
+
+// Set RPC control latency for QNN HTP backend
+static const char* const kOrtRunOptionsConfigQnnRpcControlLatency = "qnn.rpc_control_latency";
+
+// Set graph annotation id for CUDA EP. Use with enable_cuda_graph=true.
+// The value should be an integer. If the value is not set, the default value is 0 and
+// ORT session only captures one cuda graph before another capture is requested.
+// If the value is set to -1, cuda graph capture/replay is disabled in that run.
+// User are not expected to set the value to 0 as it is reserved for internal use.
+static const char* const kOrtRunOptionsConfigCudaGraphAnnotation = "gpu_graph_id";

package/Plugins/iOS~/onnxruntime.xcframework/macos-arm64_x86_64/onnxruntime.framework/{Headers → Versions/A/Headers}/onnxruntime_session_options_config_keys.h

@@ -78,21 +78,35 @@ static const char* const kOrtSessionOptionsEnableGeluApproximation = "optimizati
 static const char* const kOrtSessionOptionsDisableAheadOfTimeFunctionInlining = "session.disable_aot_function_inlining";
 
 #ifdef ENABLE_TRAINING
-// Specifies a list of op types for memory footprint reduction.
-// The value should be a ","-delimited list of pair of
-// <subgraph string: optimization strategy: number of subgraph to apply>.
-// For example, "Gelu+Cast+:1:0,Dropout+:1:1".
-//   A valid "subgraph string" should be one subgraph representation output by ORT graph transformations.
-//   "optimization strategy" currently has valid values: 0 - disabled, 1 - recompute.
-//   "number of subgraph to apply" is used to control how many subgraphs to apply optimization, to avoid "oversaving"
-//   the memory.
-static const char* const kOrtSessionOptionsMemoryOptimizerEnabler = "optimization.memory_optimizer_config";
+// Specifies a path of the file containing a list of memory optimization configurations.
+// The value should be a string indicating the file path of the config file.
+// The content of the config file is a JSON struct like this:
+// [
+//   "Gelu+Cast+:1:0",
+//   "Dropout+:1:1"
+// ]
+// Taking the example of "Gelu+Cast+:1:0",
+// > "Gelu+Cast+" is the subgraph string, a valid "subgraph string" should be one subgraph representation
+//    output by ORT graph transformations.
+// > "1" is "optimization strategy", valid values: 0 - disabled, 1 - recompute.
+// > "0" is "number of subgraph to apply" which is used to control how many subgraphs to apply optimization,
+//    to avoid "oversaving" the memory.
+static const char* const kOrtSessionOptionsMemoryOptimizerApplyConfig = "optimization.memory_optimizer_config";
 
 // Specifies the config for detecting subgraphs for memory footprint reduction.
 // The value should be a string contains int separated using commas. The default value is "0:0".
 static const char* const kOrtSessionOptionsMemoryOptimizerProbeConfig = "optimization.enable_memory_probe_recompute_config";
 #endif
 
+// This setting if set should contain a comma separated list of optimizers names that should be disabled.
+// Optimizers may take time to execute and affect model loading time. If you feel that a specific optimizer
+// does not provider runtime benefits, but affects your model loading time you may disable it using this config
+// entry. This option is not enabled in ORT_MINIMAL_BUILD build.
+// A list of optimizes is available in onnxruntime/core/optimizer/graph_transformer_utils.cc
+//
+// Default is an empty string which means no optimizers are disabled.
+static const char* const kOrtSessionOptionsDisableSpecifiedOptimizers = "optimization.disable_specified_optimizers";
+
 // Enable or disable using device allocator for allocating initialized tensor memory. "1": enable; "0": disable. The default is "0".
 // Using device allocators means the memory allocation is made using malloc/new.
 static const char* const kOrtSessionOptionsUseDeviceAllocatorForInitializers = "session.use_device_allocator_for_initializers";
@@ -251,8 +265,17 @@ static const char* const kOrtSessionOptionEpContextFilePath = "ep.context_file_p
 // "1": dump the EP context into the Onnx model. (default).
 static const char* const kOrtSessionOptionEpContextEmbedMode = "ep.context_embed_mode";
 
+// Specify the EPContext node name prefix to make it unique
+// in case user need to merge/connect multiple EPContext nodes in one model
+static const char* const kOrtSessionOptionEpContextNodeNamePrefix = "ep.context_node_name_prefix";
+
 // Gemm fastmath mode provides fp32 gemm acceleration with bfloat16 based matmul.
 // Option values:
 // - "0": Gemm FastMath mode is not enabled. [DEFAULT]
 // - "1": Gemm FastMath mode is enabled.
 static const char* const kOrtSessionOptionsMlasGemmFastMathArm64Bfloat16 = "mlas.enable_gemm_fastmath_arm64_bfloat16";
+
+// When converting DQ + MatMul -> MatMulNBits, the accuracy level of the MatMulNBits is controlled by this option.
+// Refer to MatMulNBits op schema for more details.
+// If not provided, default is 4.
+static const char* const kOrtSessionOptionsQDQMatMulNBitsAccuracyLevel = "session.qdq_matmulnbits_accuracy_level";

package/Plugins/iOS~/onnxruntime.xcframework/macos-arm64_x86_64/onnxruntime.framework/{Info.plist → Versions/A/Resources/Info.plist}

@@ -9,9 +9,9 @@
 	<key>CFBundleIdentifier</key>
 	<string>com.microsoft.onnxruntime</string>
 	<key>CFBundleVersion</key>
-	<string>1.17.3</string>
+	<string>1.19.2</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.17.3</string>
+	<string>1.19.2</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundlePackageType</key>

package/README.md

@@ -18,9 +18,9 @@ NanoSAM
 
 ## Tested environment
 
-- Unity: 2022.3.19f1 (LTS)
-- ONNX Runtime: [1.17.1](https://github.com/microsoft/onnxruntime/releases/tag/v1.17.1)
-- ONNX Runtime Extensions: [0.10.0](https://github.com/microsoft/onnxruntime-extensions/releases/tag/v0.10.0)
+- Unity: 2022.3.20f1 (LTS)
+- ONNX Runtime: [1.19.2](https://github.com/microsoft/onnxruntime/releases/tag/v1.19.2)
+- ONNX Runtime Extensions: [0.12.0](https://github.com/microsoft/onnxruntime-extensions/releases/tag/v0.12.0)
 
 ### Execution Providers & Extensions
 
@@ -66,11 +66,11 @@ Pre-built libraries are available on [NPM](https://www.npmjs.com/package/com.git
     }
   ]
   "dependencies": {
-    "com.github.asus4.onnxruntime": "0.1.14",
-    "com.github.asus4.onnxruntime.unity": "0.1.14",
-    "com.github.asus4.onnxruntime.win-x64-gpu": "0.1.14",
-    "com.github.asus4.onnxruntime.linux-x64-gpu": "0.1.14",
-    "com.github.asus4.onnxruntime-extensions": "0.1.14",
+    "com.github.asus4.onnxruntime": "0.2.1",
+    "com.github.asus4.onnxruntime.unity": "0.2.1",
+    "com.github.asus4.onnxruntime.win-x64-gpu": "0.2.1",
+    "com.github.asus4.onnxruntime.linux-x64-gpu": "0.2.1",
+    "com.github.asus4.onnxruntime-extensions": "0.2.1",
     ... other dependencies
   }
 ```

package/Runtime/AssemblyInfo.shared.cs

@@ -9,24 +9,14 @@
 #elif UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
 #define __ENABLE_COREML__
 #endif
-
-#if __XAMARIN__
-#if __IOS__
-[assembly: Foundation.LinkerSafe]
-#elif __ANDROID__
-[assembly: Android.LinkerSafe]
-#endif
-#else
-// .net 6 
 #if __IOS__
 [assembly: System.Reflection.AssemblyMetadata ("IsTrimmable", "True")]
 #elif __ANDROID__
 [assembly: global::System.Reflection.AssemblyMetadata("IsTrimmable", "True")]
 #endif
-#endif
 
 // Making these assembly's internals visible to the internal Test assembly
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.Common, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.Droid, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.iOS, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.NetCoreApp, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.NetCoreApp, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]

package/Runtime/NativeMethods.shared.cs

@@ -19,7 +19,11 @@ using System.Runtime.InteropServices;
 namespace Microsoft.ML.OnnxRuntime
 {
     [StructLayout(LayoutKind.Sequential)]
+#if NETSTANDARD2_0
+    public class OrtApiBase
+#else
     public struct OrtApiBase
+#endif
     {
         public IntPtr GetApi;
         public IntPtr GetVersionString;
@@ -29,7 +33,11 @@ namespace Microsoft.ML.OnnxRuntime
     // OrtApi ort_api_1_to_<latest_version> (onnxruntime/core/session/onnxruntime_c_api.cc)
     // If syncing your new C API, any other C APIs before yours also need to be synced here if haven't
     [StructLayout(LayoutKind.Sequential)]
+#if NETSTANDARD2_0
+    public class OrtApi
+#else
     public struct OrtApi
+#endif
     {
         public IntPtr CreateStatus;
         public IntPtr GetErrorCode;
@@ -312,8 +320,13 @@ namespace Microsoft.ML.OnnxRuntime
     {
         static OrtApi api_;
 
+#if NETSTANDARD2_0
+        [UnmanagedFunctionPointer(CallingConvention.Winapi)]
+        public delegate IntPtr DOrtGetApi(UInt32 version);
+#else
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]
         public delegate ref OrtApi DOrtGetApi(UInt32 version);
+#endif
 
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]
         public delegate IntPtr DOrtGetVersionString();
@@ -322,11 +335,24 @@ namespace Microsoft.ML.OnnxRuntime
 
         static NativeMethods()
         {
+#if NETSTANDARD2_0
+            IntPtr ortApiBasePtr = OrtGetApiBase();
+            OrtApiBase ortApiBase = (OrtApiBase)Marshal.PtrToStructure(ortApiBasePtr, typeof(OrtApiBase));
+            DOrtGetApi OrtGetApi = (DOrtGetApi)Marshal.GetDelegateForFunctionPointer(ortApiBase.GetApi, typeof(DOrtGetApi));
+#else
             DOrtGetApi OrtGetApi = (DOrtGetApi)Marshal.GetDelegateForFunctionPointer(OrtGetApiBase().GetApi, typeof(DOrtGetApi));
+#endif
 
+            const uint ORT_API_VERSION = 14;
+#if NETSTANDARD2_0
+            IntPtr ortApiPtr = OrtGetApi(ORT_API_VERSION);
+            api_ = (OrtApi)Marshal.PtrToStructure(ortApiPtr, typeof(OrtApi));
+            OrtGetVersionString = (DOrtGetVersionString)Marshal.GetDelegateForFunctionPointer(ortApiBase.GetVersionString, typeof(DOrtGetVersionString));
+#else
             // TODO: Make this save the pointer, and not copy the whole structure across
-            api_ = (OrtApi)OrtGetApi(14 /*ORT_API_VERSION*/);
+            api_ = (OrtApi)OrtGetApi(ORT_API_VERSION);
             OrtGetVersionString = (DOrtGetVersionString)Marshal.GetDelegateForFunctionPointer(OrtGetApiBase().GetVersionString, typeof(DOrtGetVersionString));
+#endif
 
             OrtCreateEnv = (DOrtCreateEnv)Marshal.GetDelegateForFunctionPointer(api_.CreateEnv, typeof(DOrtCreateEnv));
             OrtCreateEnvWithCustomLogger = (DOrtCreateEnvWithCustomLogger)Marshal.GetDelegateForFunctionPointer(api_.CreateEnvWithCustomLogger, typeof(DOrtCreateEnvWithCustomLogger));
@@ -374,6 +400,7 @@ namespace Microsoft.ML.OnnxRuntime
             OrtDisableMemPattern = (DOrtDisableMemPattern)Marshal.GetDelegateForFunctionPointer(api_.DisableMemPattern, typeof(DOrtDisableMemPattern));
             OrtEnableCpuMemArena = (DOrtEnableCpuMemArena)Marshal.GetDelegateForFunctionPointer(api_.EnableCpuMemArena, typeof(DOrtEnableCpuMemArena));
             OrtDisableCpuMemArena = (DOrtDisableCpuMemArena)Marshal.GetDelegateForFunctionPointer(api_.DisableCpuMemArena, typeof(DOrtDisableCpuMemArena));
+            OrtDisablePerSessionThreads = (DOrtDisablePerSessionThreads)Marshal.GetDelegateForFunctionPointer(api_.DisablePerSessionThreads, typeof(DOrtDisablePerSessionThreads));
             OrtSetSessionLogId = (DOrtSetSessionLogId)Marshal.GetDelegateForFunctionPointer(api_.SetSessionLogId, typeof(DOrtSetSessionLogId));
             OrtSetSessionLogVerbosityLevel = (DOrtSetSessionLogVerbosityLevel)Marshal.GetDelegateForFunctionPointer(api_.SetSessionLogVerbosityLevel, typeof(DOrtSetSessionLogVerbosityLevel));
             OrtSetSessionLogSeverityLevel = (DOrtSetSessionLogSeverityLevel)Marshal.GetDelegateForFunctionPointer(api_.SetSessionLogSeverityLevel, typeof(DOrtSetSessionLogSeverityLevel));
@@ -541,7 +568,11 @@ namespace Microsoft.ML.OnnxRuntime
         }
 
         [DllImport(NativeLib.DllName, CharSet = CharSet.Ansi)]
+#if NETSTANDARD2_0
+        public static extern IntPtr OrtGetApiBase();
+#else
         public static extern ref OrtApiBase OrtGetApiBase();
+#endif
 
 #region Runtime / Environment API
 
@@ -1004,6 +1035,10 @@ namespace Microsoft.ML.OnnxRuntime
         public delegate IntPtr /*(OrtStatus*)*/ DOrtDisableCpuMemArena(IntPtr /* OrtSessionOptions* */ options);
         public static DOrtDisableCpuMemArena OrtDisableCpuMemArena;
 
+        [UnmanagedFunctionPointer(CallingConvention.Winapi)]
+        public delegate IntPtr /*(OrtStatus*)*/ DOrtDisablePerSessionThreads(IntPtr /* OrtSessionOptions* */ options);
+        public static DOrtDisablePerSessionThreads OrtDisablePerSessionThreads;
+
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]
         public delegate IntPtr /*(OrtStatus*)*/ DOrtSetSessionLogId(IntPtr /* OrtSessionOptions* */ options, byte[] /* const char* */ logId);
         public static DOrtSetSessionLogId OrtSetSessionLogId;
@@ -1334,7 +1369,7 @@ namespace Microsoft.ML.OnnxRuntime
             OrtAllocatorType allocatorType,
             int identifier,
             OrtMemType memType,
-            out IntPtr /*(OrtMemoryInfo*)*/ allocatorInfo // memory ownership transfered to caller
+            out IntPtr /*(OrtMemoryInfo*)*/ allocatorInfo // memory ownership transferred to caller
         );
 
         public static DOrtCreateMemoryInfo OrtCreateMemoryInfo;

package/Runtime/OrtValue.shared.cs

@@ -22,7 +22,7 @@ namespace Microsoft.ML.OnnxRuntime
         ONNX_TYPE_MAP = 3,  // It's a map
         ONNX_TYPE_OPAQUE = 4, // It's an experimental Opaque object
         ONNX_TYPE_SPARSETENSOR = 5, // It's a Sparse Tensor
-        ONNX_TYPE_OPTIONAL = 6, // It's an optional type that designates anything above (except UNKOWN)
+        ONNX_TYPE_OPTIONAL = 6, // It's an optional type that designates anything above (except UNKNOWN)
     }
 
     /// <summary>
@@ -31,7 +31,7 @@ namespace Microsoft.ML.OnnxRuntime
     /// The class implements IDisposable and must
     /// be disposed of, otherwise native resources will leak
     /// and will eventually cause the application to slow down or crash.
-    /// 
+    ///
     /// If the OrtValue instance is constructed over a managed memory, and it is not
     /// disposed properly, the pinned memory will continue to be pinned and interfere
     /// with GC operation.
@@ -72,7 +72,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// Constructor. The newly constructed OrtValue takes ownership of the native OrtValue instance
         /// and disposes of it when the OrtValue instance is disposed. The instance will take ownership and will
         /// dispose of compositeMembers instances.
-        /// 
+        ///
         /// This constructor can only throw if OnnxType is not specified.
         /// </summary>
         /// <param name="handle">native ortValue handle</param>
@@ -189,10 +189,10 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Returns a ReadOnlySpan<typeparamref name="T"/> over tensor native buffer that
         /// provides a read-only view.
-        /// 
+        ///
         /// Note, that the memory may be device allocated and, therefore, not accessible from the CPU.
         /// To get memory descriptor use GetTensorMemoryInfo().
-        /// 
+        ///
         /// OrtValue must contain a non-string tensor.
         /// The span is valid as long as the OrtValue instance is alive (not disposed).
         /// </summary>
@@ -210,10 +210,10 @@ namespace Microsoft.ML.OnnxRuntime
         /// This enables you to safely and efficiently modify the underlying
         /// native buffer in a type-safe manner. This is useful for example in IOBinding scenarios
         /// where you want to modify results of the inference and feed it back as input.
-        /// 
+        ///
         /// Note, that the memory may be device allocated.
         /// To get memory descriptor use GetTensorMemoryInfo().
-        /// 
+        ///
         /// OrtValue must contain a non-string tensor.
         /// The span is valid as long as the OrtValue instance is alive (not disposed).
         /// </summary>
@@ -237,7 +237,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Fetch string tensor element buffer pointer at the specified index,
         /// convert/copy to UTF-16 char[] and return a ReadOnlyMemory<char> instance.
-        /// 
+        ///
         /// Obtain TensorTypeAndShape to get shape and element count.
         /// </summary>
         /// <param name="index">flat string tensor element index</param>
@@ -256,7 +256,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Fetch string tensor element buffer pointer at the specified index,
         /// copy/convert UTF-8 into a UTF-16 string and return it.
-        /// 
+        ///
         /// Obtain TensorTypeAndShape to get shape and element count.
         /// </summary>
         /// <param name="index">flat string tensor element index</param>
@@ -279,7 +279,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Get a span over the native memory of the string tensor element.
         /// The span is valid as long as the OrtValue is valid.
-        /// 
+        ///
         /// This is useful if you want to perform your own UTF-8 decoding or
         /// you do not care about decoding.
         /// Obtain TensorTypeAndShape to get shape and element count.
@@ -483,7 +483,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// This can be a piece of arbitrary memory that may be allocated by OrtAllocator (possibly on a device),
         /// a chunk of managed memory (must be pinned for the duration of OrtValue lifetime) or a memory that is allocated
         /// natively allocated using Marshal.AllocHGlobal(), stackalloc or other means (may be on a device).
-        /// 
+        ///
         /// The resulting OrtValue does not own the underlying memory buffer and will not attempt to
         /// deallocate it. The caller must make sure that the memory remains valid for the duration of OrtValue lifetime.
         /// </summary>
@@ -769,12 +769,12 @@ namespace Microsoft.ML.OnnxRuntime
         /// Converts the string argument represented by ReadOnlySpan to UTF-8,
         /// allocates space in the native tensor and copies it into the native tensor memory.
         /// Typically, this is used to populate a new empty string tensor element.
-        /// 
+        ///
         /// The number of elements is according to the shape supplied to CreateTensorWithEmptyStrings().
         /// However, this API can also be used to overwrite any existing element within the string tensor.
-        /// 
+        ///
         /// In general, to obtain the number of elements for any tensor, use GetTensorTypeAndShape() which
-        /// would return a disposable instance of TensorTypeAndShapeInfo. 
+        /// would return a disposable instance of TensorTypeAndShapeInfo.
         /// Then call GetElementCount() or GetShape().
         /// </summary>
         /// <param name="str">ReadOnlySpan over chars</param>
@@ -795,12 +795,12 @@ namespace Microsoft.ML.OnnxRuntime
         /// Converts the string argument represented by ReadOnlyMemory to UTF-8,
         /// allocates space in the native tensor and copies it into the native tensor memory.
         /// Typically, this is used to populate a new empty string tensor element.
-        /// 
+        ///
         /// The number of elements is according to the shape supplied to CreateTensorWithEmptyStrings().
         /// However, this API can also be used to overwrite any existing element within the string tensor.
-        /// 
+        ///
         /// In general, to obtain the number of elements for any tensor, use GetTensorTypeAndShape() which
-        /// would return a disposable instance of TensorTypeAndShapeInfo. 
+        /// would return a disposable instance of TensorTypeAndShapeInfo.
         /// Then call GetElementCount() or GetShape().
         ///
         /// </summary>
@@ -815,7 +815,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// This API resizes String Tensor element to the requested amount of bytes (UTF-8)
         /// and copies the bytes from the supplied ReadOnlySpan into the native tensor memory (resized buffer).
-        /// 
+        ///
         /// The API is useful for quick loading of utf8 data into the native tensor memory.
         /// </summary>
         /// <param name="utf8Bytes">read only span of bytes</param>
@@ -841,7 +841,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// Creates an OrtValue that contains a string tensor.
         /// String tensors are always allocated on CPU.
         /// String data will be converted to UTF-8 and copied to native memory.
-        /// 
+        ///
         /// Note, this is different from creating an OrtValue from other primitive data types
         /// where memory is pinned (if necessary) and the OrtValue points to that chunk of memory.
         /// </summary>
@@ -885,10 +885,10 @@ namespace Microsoft.ML.OnnxRuntime
         /// Creates a sequence of OrtValues from a collection of OrtValues.
         /// All OrtValues in the collection must be of the same Onnx type.
         /// I.e. (Tensor, SparseTensor, Map, Sequence, etc.)
-        /// 
+        ///
         /// The ortValues that are passed as argument are taken possession of by the newly
         /// created OrtValue. The caller should not dispose them, unless this call fails.
-        /// 
+        ///
         /// The ortValues would be empty on successful return.
         /// </summary>
         /// <param name="ortValues">a collection of OrtValues. On success the ortValues contained in the list
@@ -978,24 +978,24 @@ namespace Microsoft.ML.OnnxRuntime
         /// Creates a map OrtValue with keys and values.
         /// On a high level the Onnxruntime representation of the map always consists of two
         /// OrtValues, keys and values.
-        /// 
+        ///
         /// According to ONNX standard map keys can be unmanaged types only (or strings).
         /// Those keys are contained in a single tensor within OrtValue keys.
-        /// 
+        ///
         /// Map values, on the other hand, can be composite types. The values parameter
         /// can either contain a single tensor with unmanaged map values with the same number of
         /// elements as the keys, or it can be a sequence of OrtValues,
         /// each of those can be a composite type (tensor, sequence, map). If it is a sequence,
         /// then the number of elements must match the number of elements in keys.
-        /// 
+        ///
         /// Keys and values must be in the same order.
-        /// 
+        ///
         /// ORT supports only a subset of types for keys and values, however, this API does not
         /// restrict it.
-        /// 
+        ///
         /// The ortValues that are passed as argument are taken possession of by the newly
         /// created OrtValue. The caller should not dispose them, unless this call fails.
-        /// 
+        ///
         /// Keys and values arguments will be set to null on success.
         /// </summary>
         /// <param name="keys">Contains keys</param>
@@ -1031,10 +1031,10 @@ namespace Microsoft.ML.OnnxRuntime
         /// This API helps to quickly creates a map OrtValue with unmanaged (primitive) keys and values specified as arrays.
         /// This helps the user not to create OrtValues for keys and values separately and deal only with the final result.
         /// The map would consist of two tensors, one for keys and one for values.
-        /// 
+        ///
         /// The OrtValues would be created on top of the managed memory arrays and use it directly.
         /// The number of elements in keys and values must be the same and they must be in order.
-        /// 
+        ///
         /// The types must be unmanaged.
         /// </summary>
         /// <typeparam name="K">keys type</typeparam>
@@ -1078,10 +1078,10 @@ namespace Microsoft.ML.OnnxRuntime
         /// This helps the user not to create OrtValues for keys and values separately.
         /// The number of elements in keys and values must be the same and they must be in order.
         /// The map would consist of two tensors, one for keys and one for values.
-        /// 
+        ///
         /// string keys would be converted to UTF-8 encoding and copied to an allocated native memory.
         /// The OrtValue for values would be created on top of the managed memory using it directly.
-        /// 
+        ///
         /// The values type must be unmanaged.
         /// </summary>
         /// <typeparam name="V"></typeparam>
@@ -1128,13 +1128,13 @@ namespace Microsoft.ML.OnnxRuntime
 
         /// <summary>
         /// Creates a map OrtValue with non-string keys and string values.
-        /// 
+        ///
         /// This helps the user not to create OrtValues for keys and values separately.
         /// The number of elements in keys and values must be the same and they must be in order.
-        /// 
+        ///
         /// The OrtValue for keys would be created on top of the managed memory using it directly.
         /// string values would be converted to UTF-8 encoding and copied to an allocated native memory.
-        /// 
+        ///
         /// </summary>
         /// <typeparam name="K">unmanaged type of keys</typeparam>
         /// <param name="keys"></param>
@@ -1182,17 +1182,17 @@ namespace Microsoft.ML.OnnxRuntime
         /// Typically, when one uses GetValue() API, it creates a copy of OrtValue
         /// that points to the same buffer as keys or values. This API helps to deal with those
         /// temporary instances and avoid leaks.
-        /// 
+        ///
         /// According to ONNX standard map keys can be unmanaged types only (or strings).
         /// Those keys are contained in a single tensor within OrtValue keys. So you can query those
         /// directly from keys argument.
-        /// 
+        ///
         /// Map values, on the other hand, can be composite types. The values parameter
         /// can either contain a single tensor with unmanaged map values with the same number of
         /// elements as the keys, or it can be a sequence of OrtValues,
         /// each of those can be a composite type (tensor, sequence, map). If it is a sequence,
         /// then the number of elements must match the number of elements in keys.
-        /// 
+        ///
         /// Depending on the structure of the values, one will either directly query a single tensor
         /// from values, or will have to iterate over the sequence of OrtValues and visit each of those
         /// resulting in a recursive visitation.
@@ -1204,7 +1204,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// This API helps the user to process a map OrtValue without
         /// having to deal with the lifespan of intermediate OrtValues.
-        /// 
+        ///
         /// each API value is fed to the vistor functor.
         /// </summary>
         /// <param name="visitor">visitor function</param>

package/Runtime/SessionOptions.shared.cs

@@ -519,7 +519,12 @@ namespace Microsoft.ML.OnnxRuntime
         {
             try
             {
+#if NETSTANDARD2_0
+                var ortApiBasePtr = NativeMethods.OrtGetApiBase();
+                var ortApiBase = (OrtApiBase)Marshal.PtrToStructure(ortApiBasePtr, typeof(OrtApiBase));
+#else
                 var ortApiBase = NativeMethods.OrtGetApiBase();
+#endif
                 NativeApiStatus.VerifySuccess(
                     OrtExtensionsNativeMethods.RegisterCustomOps(this.handle, ref ortApiBase)
                 );
@@ -708,6 +713,15 @@ namespace Microsoft.ML.OnnxRuntime
         }
         private bool _enableCpuMemArena = true;
 
+        /// <summary>
+        /// Disables the per session threads. Default is true.
+        /// This makes all sessions in the process use a global TP.
+        /// </summary>
+        public void DisablePerSessionThreads()
+        {
+            NativeApiStatus.VerifySuccess(NativeMethods.OrtDisablePerSessionThreads(handle));
+        }
+
         /// <summary>
         /// Log Id to be used for the session. Default is empty string.
         /// </summary>

package/Runtime/Training/NativeTrainingMethods.shared.cs

@@ -53,8 +53,14 @@ namespace Microsoft.ML.OnnxRuntime
             static OrtTrainingApi trainingApi_;
             static IntPtr trainingApiPtr;
 
+#if NETSTANDARD2_0
+            [UnmanagedFunctionPointer(CallingConvention.Winapi)]
+            public delegate IntPtr DOrtGetApi(UInt32 version);
+#else
             [UnmanagedFunctionPointer(CallingConvention.Winapi)]
             public delegate ref OrtApi DOrtGetApi(UInt32 version);
+#endif
+
 
             [UnmanagedFunctionPointer(CallingConvention.Winapi)]
             public delegate IntPtr /* OrtTrainingApi* */ DOrtGetTrainingApi(UInt32 version);
@@ -62,13 +68,25 @@ namespace Microsoft.ML.OnnxRuntime
 
         static NativeTrainingMethods()
             {
+#if NETSTANDARD2_0
+                IntPtr ortApiBasePtr = NativeMethods.OrtGetApiBase();
+                OrtApiBase ortApiBase = (OrtApiBase)Marshal.PtrToStructure(ortApiBasePtr, typeof(OrtApiBase));
+                DOrtGetApi OrtGetApi = (DOrtGetApi)Marshal.GetDelegateForFunctionPointer(ortApiBase.GetApi, typeof(DOrtGetApi));
+#else
                 DOrtGetApi OrtGetApi = (DOrtGetApi)Marshal.GetDelegateForFunctionPointer(NativeMethods.OrtGetApiBase().GetApi, typeof(DOrtGetApi));
+#endif
 
+                const uint ORT_API_VERSION = 19;
+#if NETSTANDARD2_0
+                IntPtr ortApiPtr = OrtGetApi(ORT_API_VERSION);
+                api_ = (OrtApi)Marshal.PtrToStructure(ortApiPtr, typeof(OrtApi));
+#else
                 // TODO: Make this save the pointer, and not copy the whole structure across
-                api_ = (OrtApi)OrtGetApi(17 /*ORT_API_VERSION*/);
+                api_ = (OrtApi)OrtGetApi(ORT_API_VERSION);
+#endif
 
                 OrtGetTrainingApi = (DOrtGetTrainingApi)Marshal.GetDelegateForFunctionPointer(api_.GetTrainingApi, typeof(DOrtGetTrainingApi));
-                trainingApiPtr = OrtGetTrainingApi(17 /*ORT_API_VERSION*/);
+                trainingApiPtr = OrtGetTrainingApi(ORT_API_VERSION);
                 if (trainingApiPtr != IntPtr.Zero)
                 {
                     trainingApi_ = (OrtTrainingApi)Marshal.PtrToStructure(trainingApiPtr, typeof(OrtTrainingApi));