Update

[ghstack-poisoned]

Author: JCNTH

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

@@ -9,7 +9,7 @@
 # private prebuilt:
 #   * Dawn  : Google's official nightly prebuilt, downloaded directly from
 #             github.com/google/dawn/releases (pinned tag+rev+sha256) -- the same
-#             "fetch upstream's published binary" pattern as setup-wgpu-native.sh.
+#             "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.
 # Dawn (Chrome's WebGPU impl; its WGSL compiler Tint is the spec reference) on

backends/webgpu/CMakeLists.txt

@@ -59,7 +59,7 @@ target_link_libraries(webgpu_backend PRIVATE vulkan_schema executorch_core)
 find_package(Threads REQUIRED)
 find_package(Dawn REQUIRED)
 set(WEBGPU_GPU_LIB dawn::webgpu_dawn)
-target_link_libraries(webgpu_backend PUBLIC dawn::webgpu_dawn)
+target_link_libraries(webgpu_backend PUBLIC ${WEBGPU_GPU_LIB})
 
 if(APPLE)
   target_link_libraries(

backends/webgpu/runtime/WebGPUCompat.h

@@ -22,13 +22,11 @@ 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, WGPUDevice device) {
+inline void webgpu_poll(WGPUInstance instance) {
 #if defined(__EMSCRIPTEN__)
   (void)instance;
-  (void)device;
   emscripten_sleep(0);
 #else
-  (void)device;
   wgpuInstanceProcessEvents(instance);
   std::this_thread::sleep_for(std::chrono::microseconds(50));
 #endif

backends/webgpu/runtime/WebGPUGraph.cpp

@@ -512,7 +512,7 @@ void WebGPUGraph::copy_outputs(std::vector<std::pair<void*, size_t>>& outputs) {
 
   bool all_mapped = false;
   while (!all_mapped) {
-    webgpu_poll(instance_, device_);
+    webgpu_poll(instance_);
     all_mapped = true;
     for (size_t i = 0; i < count; i++) {
       if (outputs[i].second != 0 && !cb_data[i].done) {

backends/webgpu/test/native/test_dispatch_order.cpp

@@ -47,13 +47,15 @@ std::vector<float> read_f32_bin(const std::string& path) {
   if (!f) {
     return {};
   }
-  const size_t bytes =
-      static_cast<size_t>(f.tellg()) / sizeof(float) * sizeof(float);
+  const auto file_size = static_cast<size_t>(f.tellg());
+  if (file_size % sizeof(float) != 0) {
+    return {}; // truncated/corrupt golden; caller treats empty as failure
+  }
   f.seekg(0);
-  std::vector<float> data(bytes / sizeof(float));
+  std::vector<float> data(file_size / sizeof(float));
   f.read(
       reinterpret_cast<char*>(data.data()),
-      static_cast<std::streamsize>(bytes));
+      static_cast<std::streamsize>(file_size));
   return data;
 }
 

backends/webgpu/test/native/test_scratch_buffer.cpp

@@ -66,8 +66,10 @@ std::vector<float> readback(
   ci.callback = map_cb;
   ci.userdata1 = &cb;
   wgpuBufferMapAsync(staging, WGPUMapMode_Read, 0, nbytes, ci);
-  while (!cb.done) {
-    webgpu_poll(instance, device);
+  // Bounded poll so a never-delivered callback fails the test instead of
+  // hanging forever (~5s at 50us/spin).
+  for (int spins = 0; !cb.done && spins < 100000; ++spins) {
+    webgpu_poll(instance);
   }
 
   std::vector<float> out(nbytes / sizeof(float));