Make WebGPU EP compatible with EP API

.github/workflows/windows_webgpu.yml

@@ -155,6 +155,86 @@ jobs:
         working-directory: ${{ github.workspace }}\csharp
         continue-on-error: true
 
+  webgpu_plugin_build_x64_RelWithDebInfo:
+    runs-on: [
+      "self-hosted",
+      "1ES.Pool=onnxruntime-github-Win2022-GPU-A10",
+      "JobId=webgpu_plugin_build_x64_RelWithDebInfo-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}"
+      ]
+    timeout-minutes: 300
+    env:
+      OnnxRuntimeBuildDirectory: ${{ github.workspace }}
+      setVcvars: true
+      ALLOW_RELEASED_ONNX_OPSET_ONLY: "0"
+      DocUpdateNeeded: false
+      NVIDIA_TF32_OVERRIDE: "0"
+      ONNXRUNTIME_TEST_GPU_DEVICE_ID: "0"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: none
+
+      - name: Setup Python 3.12
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+          architecture: x64
+
+      - name: Locate vcvarsall and Setup Env
+        uses: ./.github/actions/locate-vcvarsall-and-setup-env
+        with:
+          architecture: x64
+
+      - name: Install python modules
+        run: python -m pip install -r tools\ci_build\github\windows\python\requirements.txt
+        shell: cmd
+        working-directory: ${{ github.workspace }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: "20.x"
+
+      - uses: actions/cache@v5
+        id: onnx-node-tests-cache
+        with:
+          path: ${{ github.workspace }}/js/test/
+          key: onnxnodetests-${{ hashFiles('js/scripts/prepare-onnx-node-tests.ts') }}
+
+      - name: Build and Test
+        shell: pwsh
+        run: |
+          python.exe ${{ github.workspace }}\tools\ci_build\build.py `
+            --config RelWithDebInfo `
+            --build_dir ${{ github.workspace }} `
+            --skip_submodule_sync `
+            --parallel `
+            --use_binskim_compliant_compile_flags `
+            --cmake_generator "Visual Studio 17 2022" `
+            --enable_onnx_tests `
+            --use_webgpu shared_lib `
+            --wgsl_template static `
+            --use_vcpkg --use_vcpkg_ms_internal_asset_cache `
+            --cmake_extra_defines onnxruntime_BUILD_UNIT_TESTS=ON onnxruntime_ENABLE_DAWN_BACKEND_D3D12=1 onnxruntime_ENABLE_DAWN_BACKEND_VULKAN=1 `
+            --disable_rtti `
+            --enable_lto
+
+          if ($lastExitCode -ne 0) {
+            exit $lastExitCode
+          }
+
+      - name: Publish artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: webgpu-plugin-binaries
+          path: |
+            ${{ github.workspace }}/RelWithDebInfo/RelWithDebInfo/onnxruntime_providers_webgpu.dll
+            ${{ github.workspace }}/RelWithDebInfo/RelWithDebInfo/onnxruntime_providers_webgpu.pdb
+            ${{ github.workspace }}/RelWithDebInfo/RelWithDebInfo/dxcompiler.dll
+            ${{ github.workspace }}/RelWithDebInfo/RelWithDebInfo/dxil.dll
+
   webgpu_external_dawn_build_x64_RelWithDebInfo:
     runs-on: [
         "self-hosted",

cmake/onnxruntime_providers_webgpu.cmake

@@ -56,7 +56,7 @@
     endif()
     source_group(TREE ${ONNXRUNTIME_ROOT} FILES ${onnxruntime_providers_webgpu_cc_srcs})
 
-    onnxruntime_add_shared_library(onnxruntime_providers_webgpu ${onnxruntime_providers_webgpu_cc_srcs})
+    onnxruntime_add_shared_library_module(onnxruntime_providers_webgpu ${onnxruntime_providers_webgpu_cc_srcs})
     onnxruntime_add_include_to_target(onnxruntime_providers_webgpu
         ${REPO_ROOT}/include/onnxruntime/core/session
         onnxruntime_common
@@ -119,6 +119,12 @@
     if (CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
       message(FATAL_ERROR "WebGPU EP shared library build is not supported on Emscripten. Please use static library build.")
     endif()
+
+    # Configure precompiled headers for shared library build
+    # PCH ensures ep/adapters.h is included first and improves compilation speed
+    target_precompile_headers(onnxruntime_providers_webgpu PRIVATE
+      "${REPO_ROOT}/include/onnxruntime/ep/adapters.h"
+    )
   endif()
 
   set_target_properties(onnxruntime_providers_webgpu PROPERTIES CXX_STANDARD_REQUIRED ON)

cmake/onnxruntime_unittests.cmake

@@ -1042,6 +1042,18 @@ function(onnxruntime_apply_test_target_workarounds target)
   endif()
 endfunction()
 
+# Set environment variables for plugin EP tests when run via CTest.
+function(onnxruntime_set_plugin_ep_test_environment target)
+  if(onnxruntime_USE_WEBGPU AND onnxruntime_USE_EP_API_ADAPTERS)
+    set(ORT_PLUGIN_EP_JSON_CONFIG "{\"ep_library_registration_name\": \"WebGPU_PluginEP\", \"ep_library_path\": \"$<TARGET_FILE_NAME:onnxruntime_providers_webgpu>\", \"selected_ep_name\": \"WebGpuExecutionProvider\"}")
+    set_tests_properties(${target} PROPERTIES
+      ENVIRONMENT "ORT_UNIT_TEST_MAIN_DYNAMIC_PLUGIN_EP_CONFIG_JSON=${ORT_PLUGIN_EP_JSON_CONFIG}"
+    )
+  # TODO: add for other plugin EPs if needed
+  # elseif()
+  endif()
+endfunction()
+
 function(onnxruntime_apply_emscripten_test_link_settings target)
   if (CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
     set_target_properties(${target} PROPERTIES LINK_DEPENDS ${TEST_SRC_DIR}/wasm/onnxruntime_test_adapter.js)
@@ -1250,6 +1262,7 @@ block()
   )
 
   onnxruntime_apply_test_target_workarounds(onnxruntime_provider_test)
+  onnxruntime_set_plugin_ep_test_environment(onnxruntime_provider_test)
 
   # Expose QNN SDK headers to unit tests via an interface target
   if(onnxruntime_USE_QNN)

include/onnxruntime/ep/adapter/allocator.h

@@ -18,23 +18,50 @@ namespace adapter {
 /// </summary>
 class Allocator : public OrtAllocator {
  public:
+  /**
+   * Create from an existing AllocatorPtr.
+   */
   explicit Allocator(const OrtMemoryInfo* memory_info, AllocatorPtr impl)
-      : OrtAllocator{}, memory_info_(memory_info), impl_(impl) {
+      : Allocator{memory_info} {
+    ORT_ENFORCE(impl != nullptr, "Allocator implementation cannot be null.");
+    impl_ = impl;
+  }
+
+  using AllocatorFactory = AllocatorPtr (*)(const OrtMemoryInfo& memory_info);
+
+  /**
+   * Create from an AllocatorFactory, which will be called lazily when the first allocation is made.
+   */
+  explicit Allocator(const OrtMemoryInfo* memory_info, AllocatorFactory get_allocator_impl)
+      : Allocator{memory_info} {
+    get_allocator_impl_ = get_allocator_impl;
+  }
+
+ private:
+  explicit Allocator(const OrtMemoryInfo* memory_info)
+      : OrtAllocator{}, memory_info_(memory_info) {
     version = ORT_API_VERSION;
     Alloc = AllocImpl;
     Free = FreeImpl;
     Info = InfoImpl;
   }
+  AllocatorPtr GetImpl() {
+    if (!impl_) {
+      std::call_once(init_flag_, [this]() {
+        impl_ = get_allocator_impl_(*memory_info_);
+      });
+    }
+    return impl_;
+  }
 
- private:
   static void* ORT_API_CALL AllocImpl(OrtAllocator* this_ptr, size_t size) noexcept {
     auto* allocator = static_cast<Allocator*>(this_ptr);
-    return allocator->impl_->Alloc(size);
+    return allocator->GetImpl()->Alloc(size);
   }
 
   static void ORT_API_CALL FreeImpl(OrtAllocator* this_ptr, void* p) noexcept {
     auto* allocator = static_cast<Allocator*>(this_ptr);
-    allocator->impl_->Free(p);
+    allocator->GetImpl()->Free(p);
   }
 
   static const OrtMemoryInfo* ORT_API_CALL InfoImpl(const OrtAllocator* this_ptr) noexcept {
@@ -44,6 +71,8 @@ class Allocator : public OrtAllocator {
 
   const OrtMemoryInfo* memory_info_;
   AllocatorPtr impl_;
+  AllocatorFactory get_allocator_impl_;
+  std::once_flag init_flag_;
 };
 
 }  // namespace adapter

include/onnxruntime/ep/adapter/ep.h

@@ -27,6 +27,7 @@ class Ep : public OrtEp {
         profiler_{impl_->GetProfiler()},
         temp_space_cpu_allocator_{temp_space_cpu_allocator},
         temp_space_allocator_{temp_space_allocator} {
+    ort_version_supported = ORT_API_VERSION;
   }
 
  public:

include/onnxruntime/ep/adapter/op_kernel_info.h

@@ -19,7 +19,7 @@
 #include "tensor_helper.h"
 
 namespace onnxruntime {
-struct DataTransferManager;
+class DataTransferManager;
 struct IExecutionProvider;
 }  // namespace onnxruntime
 

include/onnxruntime/ep/common.h

@@ -41,3 +41,24 @@
     OrtStatus* _status = (status_expr); \
     Ort::Status _ignored{_status};      \
   } while (false)
+
+// Helper macros to convert exceptions to OrtStatus* return values.
+// Usage:
+//   EXCEPTION_TO_RETURNED_STATUS_BEGIN
+//     ... code that may throw ...
+//   EXCEPTION_TO_RETURNED_STATUS_END
+#define EXCEPTION_TO_RETURNED_STATUS_BEGIN try {
+#define EXCEPTION_TO_RETURNED_STATUS_END                  \
+  }                                                       \
+  catch (const Ort::Exception& ex) {                      \
+    Ort::Status status(ex);                               \
+    return status.release();                              \
+  }                                                       \
+  catch (const std::exception& ex) {                      \
+    Ort::Status status(ex.what(), ORT_EP_FAIL);           \
+    return status.release();                              \
+  }                                                       \
+  catch (...) {                                           \
+    Ort::Status status("Unknown exception", ORT_EP_FAIL); \
+    return status.release();                              \
+  }

onnxruntime/core/providers/cpu/tensor/upsamplebase.h

@@ -265,8 +265,17 @@ class UpsampleBase {
     if (scales_input_idx_ > 0) {
       const Tensor* scale;
       bool get_scale = info.TryGetConstantInput(scales_input_idx_, &scale);
-      auto x_shape = node.InputDefs()[0]->Shape();
-      int64_t rank = x_shape ? x_shape->dim_size() : -1;
+      int64_t rank = -1;
+      if constexpr (std::is_same_v<KernelInfoType, onnxruntime::OpKernelInfo>) {
+        auto x_shape = node.InputDefs()[0]->Shape();
+        if (x_shape != nullptr) {
+          rank = x_shape->dim_size();
+        }
+      } else {
+        auto type_info = info.GetKernelInfo().GetInputTypeInfo(0);
+        auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
+        rank = static_cast<int64_t>(tensor_info.GetDimensionsCount());
+      }
       if (get_scale && scale->Shape().Size() > 0 && ((opset < 18) || (rank > 0 && opset >= 18))) {
         ORT_THROW_IF_ERROR(ParseScalesData(scale, scales_, rank));
         scales_cached_ = true;

onnxruntime/core/providers/webgpu/compute_context.h

@@ -107,7 +107,11 @@ class ComputeContextBase {
   // Get the logger.
   //
   inline const logging::Logger& Logger() const {
+#if defined(ORT_USE_EP_API_ADAPTERS)
+    return ep_.GetEpLogger();
+#else
     return *ep_.GetLogger();
+#endif
   }
 
   //

onnxruntime/core/providers/webgpu/controlflow/if.cc

@@ -3,6 +3,10 @@
 
 #include "core/providers/webgpu/controlflow/if.h"
 
+#if defined(ORT_USE_EP_API_ADAPTERS)
+#include "core/framework/error_code_helper.h"
+#endif
+
 using namespace ONNX_NAMESPACE;
 using namespace onnxruntime::common;
 
@@ -68,10 +72,20 @@ ONNX_OPERATOR_KERNEL_EX(If,
                             .TypeConstraint("V", DataTypeImpl::AllFixedSizeTensorTypes()),
                         If);
 
+#if !defined(ORT_USE_EP_API_ADAPTERS)
 Status If::Compute(OpKernelContext* ctx) const {
   // call the base CPU version.
   return onnxruntime::If::Compute(ctx);
 }
+#else
+Status If::CreateControlFlowKernelImpl(const OrtKernelInfo* info, OrtKernelImpl** impl) {
+  return ToStatusAndRelease(ep::Api().ep.CreateIfKernel(info, impl));
+}
+
+Status If::Compute(OpKernelContext* /*ctx*/) const {
+  return ORT_MAKE_STATUS(ONNXRUNTIME, EP_FAIL, "If operator should be handled by ORT core.");
+}
+#endif
 
 }  // namespace webgpu
-}  // namespace onnxruntime
+}  // namespace onnxruntime

onnxruntime/core/providers/webgpu/controlflow/if.h

@@ -10,6 +10,8 @@
 namespace onnxruntime {
 namespace webgpu {
 
+#if !defined(ORT_USE_EP_API_ADAPTERS)
+
 // Use the CPU implementation for the logic
 class If final : public onnxruntime::If {
  public:
@@ -18,5 +20,16 @@ class If final : public onnxruntime::If {
   Status Compute(OpKernelContext* ctx) const override;
 };
 
+#else
+
+class If final : public OpKernel {
+ public:
+  If(const OpKernelInfo& info) : OpKernel(info) {}
+
+  Status CreateControlFlowKernelImpl(const OrtKernelInfo* info, OrtKernelImpl** impl) override;
+  Status Compute(OpKernelContext* ctx) const override;
+};
+#endif
+
 }  // namespace webgpu
-}  // namespace onnxruntime
+}  // namespace onnxruntime