Merge pull request #734 from intel/sync_msft_9_7_25

BackMerging with Msft Commits

Author: ankitm3k

.github/workflows/linux-wasm-ci-build-and-test-workflow.yml

@@ -45,11 +45,28 @@ jobs:
         with:
           submodules: recursive
 
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      # The image used in this workflow has an old version of Node.js installed at /bin/node and npm at /bin/npm.
+      # We need to remove the system Node.js and npm, otherwise CMake will not be able to find the correct Node.js and npm executables.
+      - name: Remove the system Node.js
+        run: |
+          if [ -f /bin/node ]; then
+            rm /bin/node
+          fi
+          if [ -f /bin/npm ]; then
+            rm /bin/npm
+          fi
+
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
           python-version: "3.12"
           architecture: ${{ env.buildArch }}
+
       - uses: microsoft/onnxruntime-github-actions/[email protected]
         with:
           vcpkg-version: '2025.06.13'

.github/workflows/stale.yml

@@ -8,15 +8,7 @@
     ],
     "[python]": {
         "editor.tabSize": 4,
-        // Auto sort imports
-        "editor.formatOnSave": true,
-        "editor.codeActionsOnSave": {
-            "source.organizeImports": "explicit"
-        },
-        "editor.defaultFormatter": "ms-python.black-formatter"
     },
-    // Enable Python linting and Pylance type checking
-    "python.analysis.typeCheckingMode": "basic",
     "cpplint.lineLength": 120,
     "cpplint.filters": [
         "-build/include_subdir",

.vscode/settings.json

@@ -134,6 +134,7 @@ option(onnxruntime_USE_CANN "Build with CANN support" OFF)
 option(onnxruntime_USE_XNNPACK "Build with XNNPACK support. Provides an alternative math library on ARM, WebAssembly and x86." OFF)
 option(onnxruntime_USE_WEBNN "Build with WebNN support. Enable hardware acceleration in web browsers." OFF)
 option(onnxruntime_USE_WEBGPU "Build with WebGPU support. Enable WebGPU via C/C++ interface." OFF)
+option(onnxruntime_WGSL_TEMPLATE "Specify the code generator for WGSL template. Default is static." "static")
 option(onnxruntime_USE_EXTERNAL_DAWN "Build with treating Dawn as external dependency. Will not link Dawn at build time." OFF)
 option(onnxruntime_CUSTOM_DAWN_SRC_PATH "Path to custom Dawn src dir.")
 option(onnxruntime_BUILD_DAWN_MONOLITHIC_LIBRARY "Build Dawn as a monolithic library" OFF)

cmake/CMakeLists.txt

@@ -57,3 +57,4 @@ directx_headers;https://github.com/microsoft/DirectX-Headers/archive/refs/tags/v
 cudnn_frontend;https://github.com/NVIDIA/cudnn-frontend/archive/refs/tags/v1.12.0.zip;7e733cfdc410d777b76122d64232499205589a96
 dawn;https://github.com/google/dawn/archive/9733be39e18186961d503e064874afe3e9ceb8d1.zip;2a4017c32892b90d072a9102eba90ae691fae36d
 kleidiai;https://github.com/ARM-software/kleidiai/archive/refs/tags/v1.4.0.tar.gz;22d3b57b54a61c194ab256ff11b0353a3b220244
+duktape;https://github.com/svaarala/duktape/releases/download/v2.7.0/duktape-2.7.0.tar.xz;8200c8e417dbab7adcc12c4dbdef7651cfc55794

cmake/deps.txt

@@ -772,6 +772,16 @@ if (onnxruntime_USE_WEBGPU)
   if (onnxruntime_ENABLE_PIX_FOR_WEBGPU_EP)
     list(APPEND onnxruntime_EXTERNAL_LIBRARIES webgpu_glfw glfw)
   endif()
+
+  if (NOT CMAKE_SYSTEM_NAME STREQUAL "Emscripten" AND onnxruntime_WGSL_TEMPLATE STREQUAL "dynamic")
+    onnxruntime_fetchcontent_declare(
+      duktape
+      URL ${DEP_URL_duktape}
+      URL_HASH SHA1=${DEP_SHA1_duktape}
+      EXCLUDE_FROM_ALL
+    )
+    onnxruntime_fetchcontent_makeavailable(duktape)
+  endif()
 endif()
 
 if(onnxruntime_USE_COREML)

cmake/external/onnxruntime_external_deps.cmake

@@ -9,6 +9,17 @@
   if (onnxruntime_ENABLE_WEBASSEMBLY_THREADS)
     add_definitions(-DENABLE_WEBASSEMBLY_THREADS=1)
   endif()
+  if (onnxruntime_WGSL_TEMPLATE STREQUAL "dynamic")
+    if (onnxruntime_DISABLE_EXCEPTIONS)
+      message(FATAL_ERROR "Dynamic WGSL template generation requires exception handling to be enabled.")
+    endif()
+    if (CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+      message(FATAL_ERROR "Dynamic WGSL template generation is not supported when targeting WebAssembly.")
+    endif()
+    add_definitions(-DORT_WGSL_TEMPLATE_DYNAMIC=1)
+  elseif (NOT onnxruntime_WGSL_TEMPLATE STREQUAL "static")
+    message(FATAL_ERROR "Unsupported value for onnxruntime_WGSL_TEMPLATE: ${onnxruntime_WGSL_TEMPLATE}. Supported values are 'static' or 'dynamic'.")
+  endif()
   file(GLOB_RECURSE onnxruntime_providers_webgpu_cc_srcs CONFIGURE_DEPENDS
     "${ONNXRUNTIME_ROOT}/core/providers/webgpu/*.h"
     "${ONNXRUNTIME_ROOT}/core/providers/webgpu/*.cc"
@@ -20,6 +31,7 @@
 
   source_group(TREE ${REPO_ROOT} FILES ${onnxruntime_providers_webgpu_cc_srcs})
   onnxruntime_add_static_library(onnxruntime_providers_webgpu ${onnxruntime_providers_webgpu_cc_srcs})
+  target_compile_features(onnxruntime_providers_webgpu PRIVATE cxx_std_20)
   onnxruntime_add_include_to_target(onnxruntime_providers_webgpu
     onnxruntime_common onnx onnx_proto flatbuffers::flatbuffers Boost::mp11 safeint_interface)
 
@@ -117,4 +129,95 @@
   endif()
 
   add_dependencies(onnxruntime_providers_webgpu ${onnxruntime_EXTERNAL_DEPENDENCIES})
+
+  if (onnxruntime_WGSL_TEMPLATE)
+    # Define the WGSL templates directory and output directory
+    set(WGSL_TEMPLATES_DIR "${ONNXRUNTIME_ROOT}/core/providers/webgpu/wgsl_templates")
+    set(WGSL_GENERATED_ROOT "${CMAKE_CURRENT_BINARY_DIR}/wgsl_generated")
+
+    # Find npm and node executables
+    find_program(NPM_EXECUTABLE "npm.cmd" "npm" REQUIRED)
+    if(NOT NPM_EXECUTABLE)
+      message(FATAL_ERROR "npm is required for WGSL template generation but was not found")
+    endif()
+    find_program(NODE_EXECUTABLE "node" REQUIRED)
+    if (NOT NODE_EXECUTABLE)
+      message(FATAL_ERROR "Node is required for WGSL template generation but was not found")
+    endif()
+
+    # Install npm dependencies
+    add_custom_command(
+      OUTPUT "${WGSL_TEMPLATES_DIR}/node_modules/.install_complete"
+      COMMAND ${NPM_EXECUTABLE} ci
+      COMMAND ${CMAKE_COMMAND} -E touch "${WGSL_TEMPLATES_DIR}/node_modules/.install_complete"
+      DEPENDS "${WGSL_TEMPLATES_DIR}/package.json" "${WGSL_TEMPLATES_DIR}/package-lock.json"
+      WORKING_DIRECTORY ${WGSL_TEMPLATES_DIR}
+      COMMENT "Installing npm dependencies for WGSL template generation"
+      VERBATIM
+    )
+
+    if (onnxruntime_WGSL_TEMPLATE STREQUAL "static")
+      set(WGSL_GENERATED_DIR "${WGSL_GENERATED_ROOT}/wgsl_template_gen")
+      # set(WGSL_GEN_OUTPUTS "${WGSL_GENERATED_DIR}/index.h" "${WGSL_GENERATED_DIR}/index_impl.h")
+      # Define the output files that will be generated
+      set(WGSL_GENERATED_INDEX_H "${WGSL_GENERATED_DIR}/index.h")
+      set(WGSL_GENERATED_INDEX_IMPL_H "${WGSL_GENERATED_DIR}/index_impl.h")
+    elseif(onnxruntime_WGSL_TEMPLATE STREQUAL "dynamic")
+      set(WGSL_GENERATED_DIR "${WGSL_GENERATED_ROOT}/dynamic")
+      # set(WGSL_GEN_OUTPUTS "${WGSL_GENERATED_DIR}/templates.js")
+      set(WGSL_GENERATED_TEMPLATES_JS "${WGSL_GENERATED_DIR}/templates.js")
+    endif()
+
+    # Ensure the output directory exists
+    file(MAKE_DIRECTORY ${WGSL_GENERATED_DIR})
+
+    # Find all WGSL template input files
+    file(GLOB_RECURSE WGSL_TEMPLATE_FILES "${ONNXRUNTIME_ROOT}/core/providers/webgpu/*.wgsl.template")
+
+    # Set wgsl-gen command line options as a list
+    set(WGSL_GEN_OPTIONS "-i" "../" "--output" "${WGSL_GENERATED_DIR}" "-I" "wgsl_template_gen/" "--preserve-code-ref" "--verbose")
+    if (onnxruntime_WGSL_TEMPLATE STREQUAL "static")
+      if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+        list(APPEND WGSL_GEN_OPTIONS "--generator" "static-cpp-literal")
+      else()
+        list(APPEND WGSL_GEN_OPTIONS "--generator" "static-cpp")
+      endif()
+    elseif(onnxruntime_WGSL_TEMPLATE STREQUAL "dynamic")
+      list(APPEND WGSL_GEN_OPTIONS "--generator" "dynamic")
+    endif()
+
+    # Generate WGSL templates
+    add_custom_command(
+      OUTPUT ${WGSL_GENERATED_INDEX_H} ${WGSL_GENERATED_INDEX_IMPL_H} ${WGSL_GENERATED_TEMPLATES_JS}
+      COMMAND ${NPM_EXECUTABLE} run gen -- ${WGSL_GEN_OPTIONS}
+      DEPENDS "${WGSL_TEMPLATES_DIR}/node_modules/.install_complete" ${WGSL_TEMPLATE_FILES}
+      WORKING_DIRECTORY ${WGSL_TEMPLATES_DIR}
+      COMMENT "Generating WGSL templates from *.wgsl.template files"
+      COMMAND_EXPAND_LISTS
+      VERBATIM
+    )
+
+    # Create a target to represent the generation step
+    add_custom_target(onnxruntime_webgpu_wgsl_generation
+      DEPENDS ${WGSL_GENERATED_INDEX_H} ${WGSL_GENERATED_INDEX_IMPL_H} ${WGSL_GENERATED_TEMPLATES_JS}
+      SOURCES ${WGSL_TEMPLATE_FILES}
+    )
+
+    if (onnxruntime_WGSL_TEMPLATE STREQUAL "static")
+      # Add the generated directory to include paths
+      target_include_directories(onnxruntime_providers_webgpu PRIVATE ${WGSL_GENERATED_ROOT})
+    elseif(onnxruntime_WGSL_TEMPLATE STREQUAL "dynamic")
+      add_library(duktape_static STATIC "${duktape_SOURCE_DIR}/src/duktape.c")
+      target_compile_features(duktape_static PRIVATE c_std_99)
+      target_link_libraries(onnxruntime_providers_webgpu duktape_static)
+      target_include_directories(onnxruntime_providers_webgpu PRIVATE ${duktape_SOURCE_DIR}/src)
+      # Define the path to the generated templates.js file
+      target_compile_definitions(onnxruntime_providers_webgpu PRIVATE
+        "ORT_WGSL_TEMPLATES_JS_PATH=\"${WGSL_GENERATED_TEMPLATES_JS}\"")
+    endif()
+
+    # Make sure generation happens before building the provider
+    add_dependencies(onnxruntime_providers_webgpu onnxruntime_webgpu_wgsl_generation)
+  endif()
+
   set_target_properties(onnxruntime_providers_webgpu PROPERTIES FOLDER "ONNXRuntime")

cmake/onnxruntime_providers_webgpu.cmake

@@ -84,7 +84,7 @@ def parse_args():
 
 
 def create_existing_data_map(pb_files: list[Path]):
-    import onnx_test_data_utils as data_utils
+    import onnx_test_data_utils as data_utils  # noqa: PLC0415
 
     data_map = {}
     for file in pb_files:
@@ -101,7 +101,7 @@ def add_model_and_test_data_to_app(
     input_map: dict[str, np.ndarray] | None = None,
     output_map: dict[str, np.ndarray] | None = None,
 ):
-    import ort_test_dir_utils as utils
+    import ort_test_dir_utils as utils  # noqa: PLC0415
 
     output_path = SOLUTION_DIR / "Resources" / "Raw"
     test_name = "test_data"

csharp/tools/MauiModelTester/create_test_data.py

@@ -2053,6 +2053,8 @@ This version of the operator has been available since version 1 of the 'com.micr
 #### Attributes
 
 <dl>
+<dt><tt>bits</tt> : int</dt>
+<dd>Number of bits used for weight quantization. Must be either 4 or 8. </dd>
 <dt><tt>block_size</tt> : int</dt>
 <dd>(Optional) block size used for weight quantization. It needs to be a power of 2 and not smaller than 16.</dd>
 <dt><tt>gather_axis</tt> : int</dt>

docs/ContribOperators.md

@@ -23,7 +23,7 @@
 
 def get_template():
     try:
-        from jinja2 import Template
+        from jinja2 import Template  # noqa: PLC0415
     except ImportError:  # pragma no cover
 
         class Template:
@@ -251,7 +251,7 @@ def _clean_unicode(text):
 
 
 def _populate__get_all_schemas_with_history():
-    import onnxruntime.capi.onnxruntime_pybind11_state as rtpy
+    import onnxruntime.capi.onnxruntime_pybind11_state as rtpy  # noqa: PLC0415
 
     get_schemas = rtpy.get_all_operator_schema or rtpy.get_all_opkernel_def
 
@@ -885,7 +885,7 @@ def setup(app):
     Sphinx extension `onnx_sphinx` displays documentation
     of all ONNX Operators.
     """
-    import sphinx
+    import sphinx  # noqa: PLC0415
 
     app.add_config_value("onnx_doc_folder", "operators", "env")
     app.add_config_value("max_opsets", {}, "env")