Merge branch 'microsoft:main' into main

Author: orlmon01

.vscode/settings.json

@@ -14,5 +14,23 @@
         "-build/include_subdir",
         "-runtime/references"
     ],
-    "C_Cpp.autoAddFileAssociations": false
+    "C_Cpp.autoAddFileAssociations": false,
+
+    // Exclude build directories and non-essential folders from C++ parsing
+    "C_Cpp.files.exclude": {
+        "**/build/**": true,
+        "**/build_*/**": true,
+        "**/cmake/external/**": true,
+        "**/node_modules/**": true,
+        "**/.git/**": true
+    },
+
+    // Exclude from search but keep in explorer
+    "search.exclude": {
+        "**/build/**": true,
+        "**/build_*/**": true,
+        "**/cmake/external/**": true,
+        "**/node_modules/**": true,
+        "**/.git/**": true
+    }
 }

cmake/CMakeLists.txt

@@ -1801,8 +1801,11 @@ if (onnxruntime_ENABLE_EXTERNAL_CUSTOM_OP_SCHEMAS)
   )
 endif()
 
-if(NOT onnxruntime_BUILD_SHARED_LIB AND onnxruntime_USE_WEBGPU)
-  message(WARNING "CMake target files will not be generated for static onnxruntime builds with webgpu support")
+if (NOT onnxruntime_BUILD_SHARED_LIB AND
+    (onnxruntime_USE_WEBGPU OR (CMAKE_SYSTEM_NAME STREQUAL "Emscripten" AND onnxruntime_USE_XNNPACK)))
+  message(WARNING
+    "CMake target files will not be generated for static onnxruntime builds "
+    "with WebGPU or Emscripten+XNNPACK support")
 else()
   # Install
   include(CMakePackageConfigHelpers)

cmake/external/abseil-cpp.cmake

@@ -12,12 +12,8 @@ set(ABSL_USE_EXTERNAL_GOOGLETEST ON)
 
 # Both abseil and xnnpack create a target called memory, which
 # results in a duplicate target if ABSL_ENABLE_INSTALL is on.
-if (onnxruntime_USE_XNNPACK)
-  set(ABSL_ENABLE_INSTALL OFF)
-else()
-  if (NOT CMAKE_SYSTEM_NAME MATCHES "AIX")
+if (NOT CMAKE_SYSTEM_NAME MATCHES "AIX")
     set(ABSL_ENABLE_INSTALL ON)
-  endif()
 endif()
 
 if(Patch_FOUND)

cmake/external/onnxruntime_external_deps.cmake

@@ -764,7 +764,11 @@ if (onnxruntime_USE_WEBGPU)
           # - (private) Fix compatibility issues with Safari. Contains the following changes:
           #   - Polyfill for `device.AdapterInfo` (returns `undefined` in Safari v26.0)
           #
-          ${Patch_EXECUTABLE} --binary --ignore-whitespace -p1 < ${PROJECT_SOURCE_DIR}/patches/dawn/safari_polyfill.patch)
+          ${Patch_EXECUTABLE} --binary --ignore-whitespace -p1 < ${PROJECT_SOURCE_DIR}/patches/dawn/safari_polyfill.patch &&
+
+          # Remove the test folder to speed up potential file scan operations (70k+ files not needed for build).
+          # Using <SOURCE_DIR> token ensures the correct absolute path regardless of working directory.
+          ${CMAKE_COMMAND} -E rm -rf <SOURCE_DIR>/test)
 
       onnxruntime_fetchcontent_declare(
         dawn

cmake/external/xnnpack.cmake

@@ -62,6 +62,8 @@ ELSEIF(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
   SET(ORT_TARGET_PROCESSOR "arm64")
 ELSEIF(CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc64le")
   SET(ORT_TARGET_PROCESSOR "ppc64")
+ELSEIF(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  SET(ORT_TARGET_PROCESSOR "wasm")
 ELSEIF(NOT ORT_TARGET_PROCESSOR MATCHES "^(x86(_64)?|arm64|riscv(32|64|128)|Hexagon|ppc64)$")
   SET(ORT_TARGET_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}")
 ELSE()
@@ -90,18 +92,21 @@ onnxruntime_fetchcontent_makeavailable(googlexnnpack)
 set(XNNPACK_DIR ${googlexnnpack_SOURCE_DIR})
 set(XNNPACK_INCLUDE_DIR ${XNNPACK_DIR}/include)
 
-set(onnxruntime_EXTERNAL_LIBRARIES_XNNPACK XNNPACK xnnpack-microkernels-prod pthreadpool)
+set(onnxruntime_EXTERNAL_LIBRARIES_XNNPACK XNNPACK pthreadpool)
 if(ORT_TARGET_PROCESSOR MATCHES "^arm64.*" AND NOT CMAKE_C_COMPILER_ID STREQUAL "MSVC")
   list(APPEND onnxruntime_EXTERNAL_LIBRARIES_XNNPACK kleidiai)
 endif()
+if(NOT CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  list(APPEND onnxruntime_EXTERNAL_LIBRARIES_XNNPACK xnnpack-microkernels-prod)
+endif()
 
 # the XNNPACK CMake setup doesn't include the WASM kernels so we have to manually set those up
 if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
   # See source lists in _deps/googlexnnpack-src/BUILD.bazel for wasm_prod_microkernels
   message("Adding WebAssembly Source Files to XNNPACK")
   set(wasm_srcs "")
 
-  file(READ "${XNNPACK_DIR}/BUILD.bazel" xnnpack_bazel_config)
+  file(READ "${XNNPACK_DIR}/build_srcs.bzl" xnnpack_bazel_config)
 
   # Replace newlines with semicolon so that it is treated as a list by CMake
   # Also replace '[' and ']' so the bazel source lists don't get parsed as a nested list by cmake
@@ -139,19 +144,26 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
   GetSrcListFromBazel("TABLE_SRCS" table_srcs)
   list(APPEND wasm_srcs ${operator_srcs} ${table_srcs})
 
-  # kernels
-  list(APPEND wasm_srcs ${XNNPACK_DIR}/src/amalgam/gen/scalar.c)
-  list(APPEND wasm_srcs ${XNNPACK_DIR}/src/amalgam/gen/wasm.c)
+  set(microkernel_src "")
+
+  include(${XNNPACK_DIR}/cmake/gen/scalar_microkernels.cmake)
+  list(APPEND microkernel_src ${PROD_SCALAR_MICROKERNEL_SRCS})
+  list(APPEND microkernel_src ${PROD_WASM_MICROKERNEL_SRCS})
 
   if(onnxruntime_ENABLE_WEBASSEMBLY_RELAXED_SIMD)
-    list(APPEND wasm_srcs ${XNNPACK_DIR}/src/amalgam/gen/wasmsimd.c)
-    list(APPEND wasm_srcs ${XNNPACK_DIR}/src/amalgam/gen/wasmrelaxedsimd.c)
+    include(${XNNPACK_DIR}/cmake/gen/wasmsimd_microkernels.cmake)
+    include(${XNNPACK_DIR}/cmake/gen/wasmrelaxedsimd_microkernels.cmake)
+    list(APPEND microkernel_src ${PROD_WASMSIMD_MICROKERNEL_SRCS})
+    list(APPEND microkernel_src ${PROD_WASMRELAXEDSIMD_MICROKERNEL_SRCS})
     target_compile_options(XNNPACK PRIVATE "-msimd128")
     target_compile_options(XNNPACK PRIVATE "-mrelaxed-simd")
   elseif(onnxruntime_ENABLE_WEBASSEMBLY_SIMD)
-    list(APPEND wasm_srcs ${XNNPACK_DIR}/src/amalgam/gen/wasmsimd.c)
+    include(${XNNPACK_DIR}/cmake/gen/wasmsimd_microkernels.cmake)
+    list(APPEND microkernel_src ${PROD_WASMSIMD_MICROKERNEL_SRCS})
     target_compile_options(XNNPACK PRIVATE "-msimd128")
   endif()
+  list(TRANSFORM microkernel_src PREPEND "${XNNPACK_DIR}/")
+  list(APPEND wasm_srcs ${microkernel_src})
 
   message(DEBUG "wasm_srcs: ${wasm_srcs}\n")
   target_sources(XNNPACK PRIVATE ${wasm_srcs})

docs/Versioning.md

@@ -11,6 +11,67 @@ The version number of the current stable release can be found
 ## Release cadence
 See [Release Management](ReleaseManagement.md)
 
+## Updating the Version for a Release
+
+When preparing a release, follow these steps to update the version number across the codebase. This applies both when creating an initial release branch (updating `main`) and when preparing patch releases on release branches:
+
+### Prerequisites
+- Node.js (check [js/.nvmrc](../js/.nvmrc) for the required version)
+- npm (comes with Node.js)
+- Python 3
+
+Verify your setup:
+```bash
+node --version   # Should match the version in js/.nvmrc
+npm --version    # Should be v8.0 or newer
+```
+
+### Steps
+
+1. **Update the VERSION_NUMBER file**
+
+   Edit [VERSION_NUMBER](../VERSION_NUMBER) in the repository root to reflect the new version (e.g., `1.23.3`).
+
+2. **Run the version update script**
+
+   From the repository root, run:
+   ```bash
+   python tools/python/update_version.py
+   ```
+
+   This script automatically updates version numbers in:
+   - `docs/Versioning.md` - Adds a new row to the version table
+   - `docs/python/README.rst` - Adds release notes entry
+   - `onnxruntime/__init__.py` - Python package version
+   - `js/` packages - All NPM package versions and lock files
+
+3. **Update the C API static_assert (Manual Step)**
+
+   The script does **not** update the version check in the C API. You must manually update the `static_assert` in [onnxruntime/core/session/onnxruntime_c_api.cc](../onnxruntime/core/session/onnxruntime_c_api.cc).
+
+   Search for `static_assert(std::string_view(ORT_VERSION)` and update the version string:
+   ```cpp
+   static_assert(std::string_view(ORT_VERSION) == "X.Y.Z",
+                 "ORT_Version change detected, please follow below steps to ensure OrtApi is updated properly");
+   ```
+
+   Replace `X.Y.Z` with your new version number. The comments following this assert explain additional steps if new APIs were added to this release.
+
+4. **Review all changes**
+
+   Review all modified files. Verify:
+   - Version numbers are correct in all updated files
+   - The release notes URL format is correct (e.g., `https://github.com/Microsoft/onnxruntime/releases/tag/vX.Y.Z`)
+
+5. **Commit and create PR**
+
+   Commit all changes and create a PR targeting `main` or a release branch as appropriate.
+
+### Notes
+
+- The version table in this file and the ONNX opset compatibility information on [onnxruntime.ai](https://onnxruntime.ai/docs/reference/compatibility.html#onnx-opset-support) are the canonical sources for version compatibility information.
+- For ONNX version/opset/IR reference numbers, see the [ONNX Versioning documentation](https://github.com/onnx/onnx/blob/main/docs/Versioning.md#released-versions).
+
 # Compatibility
 
 ## Backwards compatibility

js/web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts

@@ -132,7 +132,7 @@ export const parseConvTransposeAttributes = (attributes: Record<string, unknown>
     typeof attributes.autoPad == 'undefined' ? 0 : (attributes.autoPad as number)
   ];
   const dilations = attributes.dilations as [number, number];
-  const group = attributes.group as number;
+  const group = (attributes.group as number) ?? 1; // default to 1 per ONNX spec
   const kernelShape = attributes.kernelShape as [number, number];
   const pads = attributes.pads as [number, number, number, number];
   const strides = attributes.strides as [number, number];

onnxruntime/core/platform/windows/telemetry.cc

@@ -3,6 +3,10 @@
 
 #include "core/platform/windows/telemetry.h"
 #include <mutex>
+#include <string>
+#include <vector>
+#include <cwchar>
+#include <winsvc.h>
 #include "core/common/logging/logging.h"
 #include "onnxruntime_config.h"
 
@@ -51,6 +55,80 @@ TRACELOGGING_DEFINE_PROVIDER(telemetry_provider_handle, "Microsoft.ML.ONNXRuntim
                              // {3a26b1ff-7484-7484-7484-15261f42614d}
                              (0x3a26b1ff, 0x7484, 0x7484, 0x74, 0x84, 0x15, 0x26, 0x1f, 0x42, 0x61, 0x4d),
                              TraceLoggingOptionMicrosoftTelemetry());
+
+std::string ConvertWideStringToUtf8(const std::wstring& wide) {
+  if (wide.empty())
+    return {};
+
+  const UINT code_page = CP_UTF8;
+  const DWORD flags = 0;
+  LPCWCH const src = wide.data();
+  const int src_len = static_cast<int>(wide.size());
+  int utf8_length = ::WideCharToMultiByte(code_page, flags, src, src_len, nullptr, 0, nullptr, nullptr);
+  if (utf8_length == 0)
+    return {};
+
+  std::string utf8(utf8_length, '\0');
+  if (::WideCharToMultiByte(code_page, flags, src, src_len, utf8.data(), utf8_length, nullptr, nullptr) == 0)
+    return {};
+
+  return utf8;
+}
+
+std::string GetServiceNamesForCurrentProcess() {
+  static std::once_flag once_flag;
+  static std::string service_names;
+
+  std::call_once(once_flag, [] {
+    SC_HANDLE service_manager = ::OpenSCManagerW(nullptr, nullptr, SC_MANAGER_ENUMERATE_SERVICE);
+    if (service_manager == nullptr)
+      return;
+
+    DWORD bytes_needed = 0;
+    DWORD services_returned = 0;
+    DWORD resume_handle = 0;
+    if (!::EnumServicesStatusExW(service_manager, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_ACTIVE, nullptr, 0, &bytes_needed,
+                                 &services_returned, &resume_handle, nullptr) &&
+        ::GetLastError() != ERROR_MORE_DATA) {
+      ::CloseServiceHandle(service_manager);
+      return;
+    }
+
+    if (bytes_needed == 0) {
+      ::CloseServiceHandle(service_manager);
+      return;
+    }
+
+    std::vector<uint8_t> buffer(bytes_needed);
+    auto* services = reinterpret_cast<ENUM_SERVICE_STATUS_PROCESSW*>(buffer.data());
+    services_returned = 0;
+    resume_handle = 0;
+    if (!::EnumServicesStatusExW(service_manager, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_ACTIVE, reinterpret_cast<LPBYTE>(services),
+                                 bytes_needed, &bytes_needed, &services_returned, &resume_handle, nullptr)) {
+      ::CloseServiceHandle(service_manager);
+      return;
+    }
+
+    DWORD current_pid = ::GetCurrentProcessId();
+    std::wstring aggregated;
+    bool first = true;
+    for (DWORD i = 0; i < services_returned; ++i) {
+      if (services[i].ServiceStatusProcess.dwProcessId == current_pid) {
+        if (!first) {
+          aggregated.push_back(L',');
+        }
+        aggregated.append(services[i].lpServiceName);
+        first = false;
+      }
+    }
+
+    ::CloseServiceHandle(service_manager);
+
+    service_names = ConvertWideStringToUtf8(aggregated);
+  });
+
+  return service_names;
+}
 }  // namespace
 
 #ifdef _MSC_VER
@@ -178,6 +256,7 @@ void WindowsTelemetry::LogProcessInfo() const {
 #if BUILD_INBOX
   isRedist = false;
 #endif
+  const std::string service_names = GetServiceNamesForCurrentProcess();
   TraceLoggingWrite(telemetry_provider_handle,
                     "ProcessInfo",
                     TraceLoggingBool(true, "UTCReplace_AppSessionGuid"),
@@ -189,7 +268,8 @@ void WindowsTelemetry::LogProcessInfo() const {
                     TraceLoggingString(ORT_VERSION, "runtimeVersion"),
                     TraceLoggingBool(IsDebuggerPresent(), "isDebuggerAttached"),
                     TraceLoggingBool(isRedist, "isRedist"),
-                    TraceLoggingString(ORT_CALLER_FRAMEWORK, "frameworkName"));
+                    TraceLoggingString(ORT_CALLER_FRAMEWORK, "frameworkName"),
+                    TraceLoggingString(service_names.c_str(), "serviceNames"));
 
   process_info_logged = true;
 }
@@ -278,6 +358,7 @@ void WindowsTelemetry::LogSessionCreation(uint32_t session_id, int64_t ir_versio
     execution_provider_string += i;
   }
 
+  const std::string service_names = GetServiceNamesForCurrentProcess();
   // Difference is MeasureEvent & isCaptureState, but keep in sync otherwise
   if (!captureState) {
     TraceLoggingWrite(telemetry_provider_handle,
@@ -304,7 +385,8 @@ void WindowsTelemetry::LogSessionCreation(uint32_t session_id, int64_t ir_versio
                       TraceLoggingString(model_weight_hash.c_str(), "modelWeightHash"),
                       TraceLoggingString(model_metadata_string.c_str(), "modelMetaData"),
                       TraceLoggingString(loaded_from.c_str(), "loadedFrom"),
-                      TraceLoggingString(execution_provider_string.c_str(), "executionProviderIds"));
+                      TraceLoggingString(execution_provider_string.c_str(), "executionProviderIds"),
+                      TraceLoggingString(service_names.c_str(), "serviceNames"));
   } else {
     TraceLoggingWrite(telemetry_provider_handle,
                       "SessionCreation_CaptureState",
@@ -330,7 +412,8 @@ void WindowsTelemetry::LogSessionCreation(uint32_t session_id, int64_t ir_versio
                       TraceLoggingString(model_weight_hash.c_str(), "modelWeightHash"),
                       TraceLoggingString(model_metadata_string.c_str(), "modelMetaData"),
                       TraceLoggingString(loaded_from.c_str(), "loadedFrom"),
-                      TraceLoggingString(execution_provider_string.c_str(), "executionProviderIds"));
+                      TraceLoggingString(execution_provider_string.c_str(), "executionProviderIds"),
+                      TraceLoggingString(service_names.c_str(), "serviceNames"));
   }
 }
 

onnxruntime/core/providers/cpu/cpu_provider_shared.cc

@@ -186,9 +186,9 @@ struct ProviderHostCPUImpl : ProviderHostCPU {
   std::unique_ptr<EinsumTypedComputeProcessor<float>> EinsumTypedComputeProcessor_float__Create(OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets) override { return std::make_unique<EinsumTypedComputeProcessor<float>>(context, allocator, tp, einsum_compute_preprocessor, einsum_cuda_assets); }
   std::unique_ptr<EinsumTypedComputeProcessor<double>> EinsumTypedComputeProcessor_double__Create(OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets) override { return std::make_unique<EinsumTypedComputeProcessor<double>>(context, allocator, tp, einsum_compute_preprocessor, einsum_cuda_assets); }
   std::unique_ptr<EinsumTypedComputeProcessor<MLFloat16>> EinsumTypedComputeProcessor_MLFloat16__Create(OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets) override { return std::make_unique<EinsumTypedComputeProcessor<MLFloat16>>(context, allocator, tp, einsum_compute_preprocessor, einsum_cuda_assets); }
-  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<float>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<float>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<float>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func); }
-  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<double>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<double>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<double>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func); }
-  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<MLFloat16>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<MLFloat16>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<MLFloat16>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func); }
+  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<float>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<float>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<float>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func, const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func, device_zero_buffer_func); }
+  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<double>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<double>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<double>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func, const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func, device_zero_buffer_func); }
+  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<MLFloat16>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<MLFloat16>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<MLFloat16>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func, const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func, device_zero_buffer_func); }
   Status EinsumTypedComputeProcessor__Run(EinsumTypedComputeProcessor<float>* p) override { return p->Run(); }
   Status EinsumTypedComputeProcessor__Run(EinsumTypedComputeProcessor<double>* p) override { return p->Run(); }
   Status EinsumTypedComputeProcessor__Run(EinsumTypedComputeProcessor<MLFloat16>* p) override { return p->Run(); }