Merge branch 'master' into sync_msft_10_4_25

Author: jatinwadhwa921

cmake/CMakeLists.txt

@@ -180,7 +180,6 @@ option(onnxruntime_ENABLE_TRAINING_OPS "Include training operators but no traini
 option(onnxruntime_ENABLE_TRAINING_E2E_TESTS "Enable training end-to-end tests." OFF)
 option(onnxruntime_ENABLE_CPU_FP16_OPS "Build with advanced instruction sets" ON)
 option(onnxruntime_USE_NCCL "Build with NCCL support" OFF)
-option(onnxruntime_USE_MPI "Build with MPI support" OFF)
 
 # WebAssembly options
 option(onnxruntime_BUILD_WEBASSEMBLY_STATIC_LIB "Enable this option to create WebAssembly static library" OFF)
@@ -1267,6 +1266,7 @@ function(onnxruntime_set_compile_flags target_name)
       # Unsupported by Clang 18 yet.
       list(REMOVE_ITEM ORT_HIP_WARNING_FLAGS -Wno-dangling-reference)
 
+      list(REMOVE_ITEM ORT_HIP_WARNING_FLAGS -Wno-interference-size)
       # float16.h:90:12: error: ‘tmp’ is used uninitialized
       list(APPEND ORT_HIP_WARNING_FLAGS -Wno-uninitialized)
       list(APPEND ORT_HIP_WARNING_FLAGS -Wno-deprecated-copy)
@@ -1650,29 +1650,6 @@ if (onnxruntime_ENABLE_DLPACK)
 endif()
 
 if (UNIX OR onnxruntime_USE_NCCL)
-  # MPI is INDEPENDENT of NCCL for now. You can build NCLL without MPI and launch multi-GPU with your own launcher.
-  if (onnxruntime_USE_MPI)
-    if (EXISTS "${onnxruntime_MPI_HOME}")
-      set(MPI_HOME "${onnxruntime_MPI_HOME}")
-    elseif (EXISTS "/bert_ort/openmpi")
-      set(MPI_HOME "/bert_ort/openmpi")
-    endif()
-    find_package(MPI)
-
-    if (MPI_CXX_FOUND)
-      message( STATUS "MPI Version: ${MPI_CXX_VERSION}")
-      message( STATUS "MPI (include: ${MPI_CXX_INCLUDE_DIRS}, library: ${MPI_CXX_LIBRARIES})" )
-      mark_as_advanced(MPI_CXX_INCLUDE_DIRS MPI_CXX_LIBRARIES)
-      list(APPEND onnxruntime_EXTERNAL_LIBRARIES ${MPI_CXX_LIBRARIES} ${MPI_CXX_LINK_FLAGS})
-    else ()
-      message(
-            FATAL_ERROR
-            "MPI is not found. Please define onnxruntime_MPI_HOME to specify the path of MPI. Otherwise, NCCL will be disabled."
-            "or you can remove --use_mpi from build args to disable MPI."
-          )
-    endif()
-  endif()
-
   # Find NCCL
   if (onnxruntime_USE_NCCL)
     if (onnxruntime_USE_CUDA)
@@ -1742,13 +1719,9 @@ if (UNIX OR onnxruntime_USE_NCCL)
   endif()
 else()
   set(onnxruntime_USE_NCCL OFF)
-  set(onnxruntime_USE_MPI OFF)
-  message( WARNING "MPI and NCCL are disabled because build is on Windows or USE_NCCL is set to OFF." )
+  message( WARNING "NCCL is disabled because build is on Windows or USE_NCCL is set to OFF." )
 endif()
 
-if (onnxruntime_USE_MPI)
-  add_definitions(-DUSE_MPI=1)
-endif()
 
 # Default version parts for Microsoft.AI.MachineLearning.dll, onnxruntime.dll, onnxruntime_providers_openvino.dll and onnxruntime_providers_shared.dll in non-ADO pipeline local builds
 set(VERSION_MAJOR_PART   0 CACHE STRING "First part of numeric file/product version.")

cmake/external/onnxruntime_external_deps.cmake

@@ -719,6 +719,11 @@ if (onnxruntime_USE_WEBGPU)
       # - (private) Remove hard-coded CMAKE_OSX_DEPLOYMENT_TARGET in Dawn's CMake files
       #   https://github.com/microsoft/onnxruntime/pull/23729
       #
+      # - (private) Reduce unsafe buffer usage warning in aligned_storage.h
+      #   https://github.com/microsoft/onnxruntime/pull/24308
+      #   The patch disables the UNSAFE_BUFFER_USAGE warning around the AlignedStorage struct in aligned_storage.h. This is done
+      #   by using TINT_BEGIN_DISABLE_WARNING and TINT_END_DISABLE_WARNING macros, which helps in warnings related to unsafe buffer usage
+      #   usage when compiling the code, making the build process cleaner and faster.
       #
       PATCH_COMMAND ${Patch_EXECUTABLE} --binary --ignore-whitespace -p1 < ${PROJECT_SOURCE_DIR}/patches/dawn/dawn.patch
       EXCLUDE_FROM_ALL

cmake/onnxruntime_framework.cmake

@@ -77,9 +77,6 @@ if (onnxruntime_ENABLE_TRAINING_OPS)
     onnxruntime_add_include_to_target(onnxruntime_framework Python::Module dlpack::dlpack)
   endif()
 endif()
-if (onnxruntime_USE_MPI)
-  target_include_directories(onnxruntime_framework PUBLIC ${MPI_CXX_INCLUDE_DIRS})
-endif()
 
 if (onnxruntime_ENABLE_ATEN)
   onnxruntime_add_include_to_target(onnxruntime_framework dlpack::dlpack)

cmake/onnxruntime_providers_cpu.cmake

@@ -206,7 +206,7 @@ if (onnxruntime_ENABLE_TRAINING)
     onnxruntime_add_include_to_target(onnxruntime_providers Python::Module)
   endif()
 
-  if (onnxruntime_USE_NCCL OR onnxruntime_USE_MPI)
+  if (onnxruntime_USE_NCCL)
     target_include_directories(onnxruntime_providers PUBLIC ${MPI_CXX_INCLUDE_DIRS})
   endif()
 endif()

cmake/onnxruntime_providers_cuda.cmake

@@ -252,10 +252,6 @@
       target_include_directories(${target} PRIVATE ${ORTTRAINING_ROOT} ${MPI_CXX_INCLUDE_DIRS})
     endif()
 
-    if(onnxruntime_USE_MPI)
-      target_link_libraries(${target} PRIVATE ${MPI_LIBRARIES} ${MPI_CXX_LINK_FLAGS})
-    endif()
-
     if (onnxruntime_USE_NCCL)
       target_include_directories(${target} PRIVATE ${NCCL_INCLUDE_DIRS})
       target_link_libraries(${target} PRIVATE ${NCCL_LIBRARIES})

cmake/onnxruntime_providers_rocm.cmake

@@ -158,9 +158,6 @@
 
   if (onnxruntime_ENABLE_TRAINING)
     target_include_directories(onnxruntime_providers_rocm PRIVATE ${ORTTRAINING_ROOT} ${CMAKE_CURRENT_BINARY_DIR}/amdgpu/orttraining ${MPI_CXX_INCLUDE_DIRS})
-    if(onnxruntime_USE_MPI)
-      target_link_libraries(onnxruntime_providers_rocm PRIVATE ${MPI_LIBRARIES} ${MPI_CXX_LINK_FLAGS})
-    endif()
 
     # RCCL is enabled by default for ROCM builds
     #if (onnxruntime_USE_NCCL)

cmake/patches/dawn/dawn.patch

@@ -36,3 +36,24 @@ index 5bfac41dcc..71a153daaa 100644
  void WGPUBufferImpl::Destroy() {
    emwgpuBufferDestroy(this);
    AbortPendingMap("Buffer was destroyed before mapping was resolved.");
+diff --git a/src/tint/utils/memory/aligned_storage.h b/src/tint/utils/memory/aligned_storage.h
+index c532c4fc38..19c950af4c 100644
+--- a/src/tint/utils/memory/aligned_storage.h
++++ b/src/tint/utils/memory/aligned_storage.h
+@@ -31,6 +31,9 @@
+ #include <cstddef>
+ 
+ #include "src/tint/utils/memory/bitcast.h"
++#include "src/tint/utils/macros/compiler.h"
++
++TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE);
+ 
+ namespace tint {
+ 
+@@ -50,4 +53,6 @@ struct alignas(alignof(T)) AlignedStorage {
+ 
+ }  // namespace tint
+ 
++TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE);
++
+ #endif  // SRC_TINT_UTILS_MEMORY_ALIGNED_STORAGE_H_

java/build.gradle

@@ -211,6 +211,7 @@ test {
 		'USE_TENSORRT',
 		'USE_QNN',
 		'USE_XNNPACK',
+		'USE_WEBGPU',
 		])
 	testLogging {
 		events "passed", "skipped", "failed"

java/src/main/java/ai/onnxruntime/OrtSession.java

@@ -1339,6 +1339,18 @@ public void addCoreML(Map<String, String> providerOptions) throws OrtException {
       addExecutionProvider(CoreMLProviderName, providerOptions);
     }
 
+    /**
+     * Adds WebGPU as an execution backend.
+     *
+     * @param providerOptions Configuration options for the WebGPU backend. Refer to the WebGPU
+     *     execution provider's documentation.
+     * @throws OrtException If there was an error in native code.
+     */
+    public void addWebGPU(Map<String, String> providerOptions) throws OrtException {
+      String webGpuProviderName = "WebGPU";
+      addExecutionProvider(webGpuProviderName, providerOptions);
+    }
+
     private native void setExecutionMode(long apiHandle, long nativeHandle, int mode)
         throws OrtException;
 

java/src/test/android/app/src/androidTest/java/ai/onnxruntime/example/javavalidator/SimpleTest.kt

@@ -52,6 +52,11 @@ class SimpleTest {
         runSigmoidModelTestImpl(1, OrtProvider.QNN)
     }
 
+    @Test
+    fun runSigmoidModelTestWEBGPU() {
+        runSigmoidModelTestImpl(1, OrtProvider.WEBGPU)
+    }
+
     @Throws(IOException::class)
     private fun readModel(fileName: String): ByteArray {
         return InstrumentationRegistry.getInstrumentation().context.assets.open(fileName)
@@ -90,6 +95,16 @@ class SimpleTest {
                     }
                 }
 
+                OrtProvider.WEBGPU -> {
+                    if (OrtEnvironment.getAvailableProviders().contains(OrtProvider.WEBGPU)) {
+                        val providerOptions = Collections.emptyMap<String, String>()
+                        opts.addWebGPU(providerOptions)
+                    } else {
+                        Log.println(Log.INFO, TAG, "NO WEBGPU EP available, skip the test")
+                        return
+                    }
+                }
+
                 OrtProvider.CPU -> {
                     // No additional configuration is needed for CPU
                 }