Update

[ghstack-poisoned]

Author: JCNTH

.ci/scripts/setup-webgpu-linux-deps.sh

@@ -10,8 +10,8 @@
 #   * Dawn  : Google's official nightly prebuilt, downloaded directly from
 #             github.com/google/dawn/releases (pinned tag+rev+sha256) -- the same
 #             "fetch a pinned upstream prebuilt" pattern used for other CI deps.
-#   * SwiftShader : reuse the prebuilt ALREADY on the ossci-android bucket (the one
-#             setup-vulkan-linux-deps.sh uses). No new S3 uploads anywhere.
+#   * SwiftShader : built from source at a pinned rev compatible with the Dawn
+#             above (the ossci prebuilt is from 2020, too old for current Dawn). No S3.
 # Dawn (Chrome's WebGPU impl; its WGSL compiler Tint is the spec reference) on
 # SwiftShader gives a headless, deterministic, spec-faithful CLI backend.
 #
@@ -24,7 +24,9 @@ set -ex
 DAWN_TAG="${DAWN_TAG:-v20260423.175430}"
 DAWN_REV="${DAWN_REV:-31e25af254ab572c77054edec4946d2244e184dd}"
 DAWN_SHA256="${DAWN_SHA256:-ac76fac090162dc1ecea5ed0f28a557bb8f49efc47faab01886105ace82b7b64}"
-SWIFTSHADER_ARCHIVE="${SWIFTSHADER_ARCHIVE:-swiftshader-abe07b943-prebuilt.tar.gz}"
+# SwiftShader rev verified compatible with DAWN_REV (the old ossci prebuilt is
+# from 2020 and is incompatible with current Dawn -> no adapter / zero compute).
+SWIFTSHADER_REV="${SWIFTSHADER_REV:-9898204d91d6a60b6a08ad74fe4ac52a6913111b}"
 
 _dawn_dir="${DAWN_PREBUILT_DIR:-/tmp/dawn-ci}"
 _ss_dir=/tmp/swiftshader
@@ -68,16 +70,28 @@ if [[ ! -d "${_dawn_dir}/lib64/cmake/Dawn" ]]; then
   tar -C "${_dawn_dir}" --strip-components=1 -xzf "${_dawn_tar}"
 fi
 
-# --- SwiftShader: reuse the existing ossci prebuilt (no new upload) -----------
-if [[ ! -f "${_ss_dir}/swiftshader/build/Linux/vk_swiftshader_icd.json" ]]; then
-  _ss_aws=https://ossci-android.s3.amazonaws.com
-  mkdir -p "${_ss_dir}"
-  curl --silent --show-error --location --fail --retry 3 --retry-all-errors \
-    --output "/tmp/${SWIFTSHADER_ARCHIVE}" "${_ss_aws}/${SWIFTSHADER_ARCHIVE}"
-  tar -C "${_ss_dir}" -xzf "/tmp/${SWIFTSHADER_ARCHIVE}"
+# --- SwiftShader: build from source at a pinned rev (no S3) -------------------
+# The old ossci prebuilt (swiftshader-abe07b943, 2020) is incompatible with the
+# current Dawn; build a matching modern SwiftShader instead. Self-contained
+# cmake build (vendored LLVM); the ICD lands under build/<OS>/.
+if [[ ! -d "${_ss_dir}/build" ]]; then
+  if [[ ! -d "${_ss_dir}/.git" ]]; then
+    git clone https://github.com/google/swiftshader "${_ss_dir}"
+  fi
+  git -C "${_ss_dir}" checkout "${SWIFTSHADER_REV}"
+  # vk_swiftshader's deps are vendored in-tree; tolerate unreachable
+  # disabled-feature submodules (angle, test-only) failing to fetch.
+  git -C "${_ss_dir}" submodule update --init --recursive || true
+  cmake -S "${_ss_dir}" -B "${_ss_dir}/build" -DCMAKE_BUILD_TYPE=Release \
+    -DSWIFTSHADER_BUILD_TESTS=OFF -DSWIFTSHADER_BUILD_PVR=OFF \
+    -DSWIFTSHADER_BUILD_BENCHMARKS=OFF
+  cmake --build "${_ss_dir}/build" --parallel "$(nproc)" --target vk_swiftshader
 fi
+_ss_icd="$(find "${_ss_dir}/build" -name vk_swiftshader_icd.json 2>/dev/null | head -1)"
+[[ -n "${_ss_icd}" ]] || { echo "ERROR: SwiftShader ICD not found after build" >&2; exit 1; }
 
+_ss_libdir="$(dirname "${_ss_icd}")"
 export Dawn_DIR="${_dawn_dir}/lib64/cmake/Dawn"
-export VK_ICD_FILENAMES="${_ss_dir}/swiftshader/build/Linux/vk_swiftshader_icd.json"
-export LD_LIBRARY_PATH="${_ss_dir}/swiftshader/build/Linux/:${LD_LIBRARY_PATH:-}"
+export VK_ICD_FILENAMES="${_ss_icd}"
+export LD_LIBRARY_PATH="${_ss_libdir}:${LD_LIBRARY_PATH:-}"
 export WEBGPU_USING_SWIFTSHADER=1

backends/webgpu/runtime/WebGPUCompat.h

@@ -10,26 +10,15 @@
 
 #include <webgpu/webgpu.h>
 
-#if defined(__EMSCRIPTEN__)
-#include <emscripten/emscripten.h>
-#else
-#include <chrono>
-#include <thread>
-#endif
+#include <cstdint>
 
 namespace executorch::backends::webgpu {
 
-// Make progress on pending WebGPU callbacks; callers loop until their done flag
-// is set. Native (Dawn): pump the event queue + brief yield (no busy-spin).
-// Browser: yield to the JS event loop.
-inline void webgpu_poll(WGPUInstance instance) {
-#if defined(__EMSCRIPTEN__)
-  (void)instance;
-  emscripten_sleep(0);
-#else
-  wgpuInstanceProcessEvents(instance);
-  std::this_thread::sleep_for(std::chrono::microseconds(50));
-#endif
+// Caller's instance must enable TimedWaitAny; returns the WaitAny status.
+inline WGPUWaitStatus webgpu_wait(WGPUInstance instance, WGPUFuture future) {
+  WGPUFutureWaitInfo info = {};
+  info.future = future;
+  return wgpuInstanceWaitAny(instance, 1, &info, UINT64_MAX);
 }
 
 } // namespace executorch::backends::webgpu

backends/webgpu/runtime/WebGPUDevice.cpp

@@ -22,12 +22,10 @@ namespace {
 
 struct AdapterResult {
   WGPUAdapter adapter = nullptr;
-  bool done = false;
 };
 
 struct DeviceResult {
   WGPUDevice device = nullptr;
-  bool done = false;
 };
 
 void on_adapter_request(
@@ -47,7 +45,6 @@ void on_adapter_request(
         static_cast<int>(message.length),
         message.data);
   }
-  result->done = true;
 }
 
 void on_device_request(
@@ -67,7 +64,6 @@ void on_device_request(
         static_cast<int>(message.length),
         message.data);
   }
-  result->done = true;
 }
 
 void on_device_error(
@@ -89,34 +85,36 @@ void on_device_error(
 WebGPUContext create_webgpu_context() {
   WebGPUContext ctx;
 
-  ctx.instance = wgpuCreateInstance(nullptr);
+  // TimedWaitAny lets webgpu_wait() block on futures via wgpuInstanceWaitAny.
+  WGPUInstanceDescriptor instance_desc = {};
+#if defined(__EMSCRIPTEN__)
+  instance_desc.capabilities.timedWaitAnyEnable = true;
+  instance_desc.capabilities.timedWaitAnyMaxCount = 1;
+#else
+  WGPUInstanceFeatureName features[1] = {WGPUInstanceFeatureName_TimedWaitAny};
+  instance_desc.requiredFeatureCount = 1;
+  instance_desc.requiredFeatures = features;
+#endif
+  ctx.instance = wgpuCreateInstance(&instance_desc);
   if (!ctx.instance) {
     throw std::runtime_error("Failed to create WebGPU instance");
   }
 
-  // Request adapter using AllowSpontaneous mode (fires during
-  // wgpuInstanceProcessEvents or any other API call).
   AdapterResult adapter_result;
   WGPURequestAdapterCallbackInfo adapter_cb = {};
-  adapter_cb.mode = WGPUCallbackMode_AllowSpontaneous;
+  adapter_cb.mode = WGPUCallbackMode_WaitAnyOnly;
   adapter_cb.callback = on_adapter_request;
   adapter_cb.userdata1 = &adapter_result;
 
-  // Release Dawn has no bundled fallback adapter; pick the platform backend
-  // (Metal on Apple, Vulkan elsewhere -- SwiftShader via VK_ICD_FILENAMES).
+  // No backend pin or forced fallback; Dawn auto-selects the adapter.
   WGPURequestAdapterOptions adapter_opts = {};
-#if defined(__APPLE__)
-  adapter_opts.backendType = WGPUBackendType_Metal;
-#else
-  adapter_opts.backendType = WGPUBackendType_Vulkan;
-#endif
+  adapter_opts.powerPreference = WGPUPowerPreference_HighPerformance;
   adapter_opts.forceFallbackAdapter = false;
-  wgpuInstanceRequestAdapter(ctx.instance, &adapter_opts, adapter_cb);
-  while (!adapter_result.done) {
-    webgpu_poll(ctx.instance);
-  }
+  WGPUWaitStatus adapter_wait = webgpu_wait(
+      ctx.instance,
+      wgpuInstanceRequestAdapter(ctx.instance, &adapter_opts, adapter_cb));
 
-  if (!adapter_result.adapter) {
+  if (adapter_wait != WGPUWaitStatus_Success || !adapter_result.adapter) {
     wgpuInstanceRelease(ctx.instance);
     ctx.instance = nullptr;
     throw std::runtime_error(
@@ -128,7 +126,7 @@ WebGPUContext create_webgpu_context() {
   // Request device
   DeviceResult device_result;
   WGPURequestDeviceCallbackInfo device_cb = {};
-  device_cb.mode = WGPUCallbackMode_AllowSpontaneous;
+  device_cb.mode = WGPUCallbackMode_WaitAnyOnly;
   device_cb.callback = on_device_request;
   device_cb.userdata1 = &device_result;
 
@@ -141,12 +139,11 @@ WebGPUContext create_webgpu_context() {
   }
   device_desc.uncapturedErrorCallbackInfo.callback = on_device_error;
 
-  wgpuAdapterRequestDevice(ctx.adapter, &device_desc, device_cb);
-  while (!device_result.done) {
-    webgpu_poll(ctx.instance);
-  }
+  WGPUWaitStatus device_wait = webgpu_wait(
+      ctx.instance,
+      wgpuAdapterRequestDevice(ctx.adapter, &device_desc, device_cb));
 
-  if (!device_result.device) {
+  if (device_wait != WGPUWaitStatus_Success || !device_result.device) {
     wgpuAdapterRelease(ctx.adapter);
     wgpuInstanceRelease(ctx.instance);
     ctx.adapter = nullptr;

backends/webgpu/runtime/WebGPUGraph.cpp

@@ -471,7 +471,6 @@ void WebGPUGraph::execute() {
 namespace {
 
 struct MapCallbackData {
-  bool done = false;
   WGPUMapAsyncStatus status = WGPUMapAsyncStatus_Error;
 };
 
@@ -482,7 +481,6 @@ void buffer_map_callback(
     void* /*userdata2*/) {
   auto* data = static_cast<MapCallbackData*>(userdata1);
   data->status = status;
-  data->done = true;
 }
 
 } // namespace
@@ -491,34 +489,29 @@ void WebGPUGraph::copy_outputs(std::vector<std::pair<void*, size_t>>& outputs) {
   const size_t count = std::min(outputs.size(), output_staging_buffers_.size());
 
   std::vector<MapCallbackData> cb_data(count);
+  std::vector<WGPUFuture> map_futures(count, WGPUFuture{});
 
   for (size_t i = 0; i < count; i++) {
     if (outputs[i].second == 0) {
-      cb_data[i].done = true;
       cb_data[i].status = WGPUMapAsyncStatus_Success;
       continue;
     }
     WGPUBufferMapCallbackInfo cb_info = {};
-    cb_info.mode = WGPUCallbackMode_AllowSpontaneous;
+    cb_info.mode = WGPUCallbackMode_WaitAnyOnly;
     cb_info.callback = buffer_map_callback;
     cb_info.userdata1 = &cb_data[i];
-    wgpuBufferMapAsync(
+    map_futures[i] = wgpuBufferMapAsync(
         output_staging_buffers_[i],
         WGPUMapMode_Read,
         0,
         outputs[i].second,
         cb_info);
   }
 
-  bool all_mapped = false;
-  while (!all_mapped) {
-    webgpu_poll(instance_);
-    all_mapped = true;
-    for (size_t i = 0; i < count; i++) {
-      if (outputs[i].second != 0 && !cb_data[i].done) {
-        all_mapped = false;
-        break;
-      }
+  for (size_t i = 0; i < count; i++) {
+    if (outputs[i].second != 0 &&
+        webgpu_wait(instance_, map_futures[i]) != WGPUWaitStatus_Success) {
+      throw std::runtime_error("WebGPU: WaitAny failed for output map");
     }
   }