gfx-rs · cwfitzgerald · Oct 1, 2025 · Oct 1, 2025 · Oct 1, 2025 · Oct 1, 2025
diff --git a/benches/benches/wgpu-benchmark/bind_groups.rs b/benches/benches/wgpu-benchmark/bind_groups.rs
@@ -155,7 +155,7 @@ fn run_bench(ctx: &mut Criterion) {
                         state
                             .device_state
                             .device
-                            .poll(wgpu::PollType::Wait)
+                            .poll(wgpu::PollType::wait_indefinitely())
                             .unwrap();
                     }
 

diff --git a/benches/benches/wgpu-benchmark/computepass.rs b/benches/benches/wgpu-benchmark/computepass.rs
@@ -489,7 +489,7 @@ fn run_bench(ctx: &mut Criterion) {
                             state
                                 .device_state
                                 .device
-                                .poll(wgpu::PollType::Wait)
+                                .poll(wgpu::PollType::wait_indefinitely())
                                 .unwrap();
                         }
 
@@ -538,7 +538,7 @@ fn run_bench(ctx: &mut Criterion) {
                         state
                             .device_state
                             .device
-                            .poll(wgpu::PollType::Wait)
+                            .poll(wgpu::PollType::wait_indefinitely())
                             .unwrap();
                     }
 
@@ -584,7 +584,7 @@ fn run_bench(ctx: &mut Criterion) {
                 state
                     .device_state
                     .device
-                    .poll(wgpu::PollType::Wait)
+                    .poll(wgpu::PollType::wait_indefinitely())
                     .unwrap();
             }
 

diff --git a/benches/benches/wgpu-benchmark/renderpass.rs b/benches/benches/wgpu-benchmark/renderpass.rs
@@ -497,7 +497,7 @@ fn run_bench(ctx: &mut Criterion) {
                             state
                                 .device_state
                                 .device
-                                .poll(wgpu::PollType::Wait)
+                                .poll(wgpu::PollType::wait_indefinitely())
                                 .unwrap();
                         }
 
@@ -544,7 +544,7 @@ fn run_bench(ctx: &mut Criterion) {
                     state
                         .device_state
                         .device
-                        .poll(wgpu::PollType::Wait)
+                        .poll(wgpu::PollType::wait_indefinitely())
                         .unwrap();
                 }
 
@@ -584,7 +584,7 @@ fn run_bench(ctx: &mut Criterion) {
                 state
                     .device_state
                     .device
-                    .poll(wgpu::PollType::Wait)
+                    .poll(wgpu::PollType::wait_indefinitely())
                     .unwrap();
             }
 

diff --git a/benches/benches/wgpu-benchmark/resource_creation.rs b/benches/benches/wgpu-benchmark/resource_creation.rs
@@ -61,7 +61,10 @@ fn run_bench(ctx: &mut Criterion) {
                         drop(buffers);
 
                         state.queue.submit([]);
-                        state.device.poll(wgpu::PollType::Wait).unwrap();
+                        state
+                            .device
+                            .poll(wgpu::PollType::wait_indefinitely())
+                            .unwrap();
                     }
 
                     duration

diff --git a/deno_webgpu/buffer.rs b/deno_webgpu/buffer.rs
@@ -177,7 +177,7 @@ impl GPUBuffer {
         {
           self
             .instance
-            .device_poll(self.device, wgpu_types::PollType::wait())
+            .device_poll(self.device, wgpu_types::PollType::wait_indefinitely())
             .unwrap();
         }
         tokio::time::sleep(Duration::from_millis(10)).await;

diff --git a/deno_webgpu/device.rs b/deno_webgpu/device.rs
@@ -685,7 +685,7 @@ impl GPUDevice {
   fn stop_capture(&self) {
     self
       .instance
-      .device_poll(self.id, wgpu_types::PollType::wait())
+      .device_poll(self.id, wgpu_types::PollType::wait_indefinitely())
       .unwrap();
     unsafe { self.instance.device_stop_graphics_debugger_capture(self.id) };
   }

diff --git a/deno_webgpu/queue.rs b/deno_webgpu/queue.rs
@@ -103,7 +103,7 @@ impl GPUQueue {
         {
           self
             .instance
-            .device_poll(self.device, wgpu_types::PollType::wait())
+            .device_poll(self.device, wgpu_types::PollType::wait_indefinitely())
             .unwrap();
         }
         tokio::time::sleep(Duration::from_millis(10)).await;

diff --git a/examples/features/src/big_compute_buffers/mod.rs b/examples/features/src/big_compute_buffers/mod.rs
@@ -80,7 +80,7 @@ pub async fn execute_gpu_inner(
         slice.map_async(wgpu::MapMode::Read, |_| {});
     }
 
-    device.poll(wgpu::PollType::Wait).unwrap();
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
 
     let mut data = Vec::new();
     for staging_buffer in &staging_buffers {

diff --git a/examples/features/src/framework.rs b/examples/features/src/framework.rs
@@ -597,7 +597,9 @@ impl<E: Example + wgpu::WasmNotSendSync> From<ExampleTestParams<E>>
 
                 let dst_buffer_slice = dst_buffer.slice(..);
                 dst_buffer_slice.map_async(wgpu::MapMode::Read, |_| ());
-                ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+                ctx.async_poll(wgpu::PollType::wait_indefinitely())
+                    .await
+                    .unwrap();
                 let bytes = dst_buffer_slice.get_mapped_range().to_vec();
 
                 wgpu_test::image::compare_image_output(

diff --git a/examples/features/src/hello_synchronization/mod.rs b/examples/features/src/hello_synchronization/mod.rs
@@ -182,7 +182,7 @@ async fn get_data<T: bytemuck::Pod>(
     let buffer_slice = staging_buffer.slice(..);
     let (sender, receiver) = flume::bounded(1);
     buffer_slice.map_async(wgpu::MapMode::Read, move |r| sender.send(r).unwrap());
-    device.poll(wgpu::PollType::wait()).unwrap();
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
     receiver.recv_async().await.unwrap().unwrap();
     output.copy_from_slice(bytemuck::cast_slice(&buffer_slice.get_mapped_range()[..]));
     staging_buffer.unmap();

diff --git a/examples/features/src/hello_workgroups/mod.rs b/examples/features/src/hello_workgroups/mod.rs
@@ -171,7 +171,7 @@ async fn get_data<T: bytemuck::Pod>(
     let buffer_slice = staging_buffer.slice(..);
     let (sender, receiver) = flume::bounded(1);
     buffer_slice.map_async(wgpu::MapMode::Read, move |r| sender.send(r).unwrap());
-    device.poll(wgpu::PollType::wait()).unwrap();
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
     receiver.recv_async().await.unwrap().unwrap();
     output.copy_from_slice(bytemuck::cast_slice(&buffer_slice.get_mapped_range()[..]));
     staging_buffer.unmap();

diff --git a/examples/features/src/mipmap/mod.rs b/examples/features/src/mipmap/mod.rs
@@ -411,7 +411,7 @@ impl crate::framework::Example for Example {
                 .slice(..)
                 .map_async(wgpu::MapMode::Read, |_| ());
             // Wait for device to be done rendering mipmaps
-            device.poll(wgpu::PollType::wait()).unwrap();
+            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
             // This is guaranteed to be ready.
             let timestamp_view = query_sets
                 .mapping_buffer

diff --git a/examples/features/src/ray_shadows/mod.rs b/examples/features/src/ray_shadows/mod.rs
@@ -360,7 +360,7 @@ impl crate::framework::Example for Example {
             rpass.draw_indexed(0..12, 0, 0..1);
         }
         queue.submit(Some(encoder.finish()));
-        device.poll(wgpu::PollType::Wait).unwrap();
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
     }
 }
 

diff --git a/examples/features/src/render_to_texture/mod.rs b/examples/features/src/render_to_texture/mod.rs
@@ -132,7 +132,7 @@ async fn run(_path: Option<String>) {
     let buffer_slice = output_staging_buffer.slice(..);
     let (sender, receiver) = flume::bounded(1);
     buffer_slice.map_async(wgpu::MapMode::Read, move |r| sender.send(r).unwrap());
-    device.poll(wgpu::PollType::wait()).unwrap();
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
     receiver.recv_async().await.unwrap().unwrap();
     log::info!("Output buffer mapped.");
     {

diff --git a/examples/features/src/repeated_compute/mod.rs b/examples/features/src/repeated_compute/mod.rs
@@ -105,7 +105,10 @@ async fn compute(local_buffer: &mut [u32], context: &WgpuContext) {
     // One of those can be calling `Device::poll`. This isn't necessary on the web as devices
     // are polled automatically but natively, we need to make sure this happens manually.
     // `PollType::Wait` will cause the thread to wait on native but not on WebGpu.
-    context.device.poll(wgpu::PollType::wait()).unwrap();
+    context
+        .device
+        .poll(wgpu::PollType::wait_indefinitely())
+        .unwrap();
     log::info!("Device polled.");
     // Now we await the receiving and panic if anything went wrong because we're lazy.
     receiver.recv_async().await.unwrap().unwrap();

diff --git a/examples/features/src/storage_texture/mod.rs b/examples/features/src/storage_texture/mod.rs
@@ -142,7 +142,7 @@ async fn run(_path: Option<String>) {
     let buffer_slice = output_staging_buffer.slice(..);
     let (sender, receiver) = flume::bounded(1);
     buffer_slice.map_async(wgpu::MapMode::Read, move |r| sender.send(r).unwrap());
-    device.poll(wgpu::PollType::wait()).unwrap();
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
     receiver.recv_async().await.unwrap().unwrap();
     log::info!("Output buffer mapped");
     {

diff --git a/examples/features/src/timestamp_queries/mod.rs b/examples/features/src/timestamp_queries/mod.rs
@@ -161,7 +161,7 @@ impl Queries {
         self.destination_buffer
             .slice(..)
             .map_async(wgpu::MapMode::Read, |_| ());
-        device.poll(wgpu::PollType::wait()).unwrap();
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
 
         let timestamps = {
             let timestamp_view = self

diff --git a/examples/standalone/01_hello_compute/src/main.rs b/examples/standalone/01_hello_compute/src/main.rs
@@ -242,7 +242,7 @@ fn main() {
 
     // Wait for the GPU to finish working on the submitted work. This doesn't work on WebGPU, so we would need
     // to rely on the callback to know when the buffer is mapped.
-    device.poll(wgpu::PollType::Wait).unwrap();
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
 
     // We can now read the data from the buffer.
     let data = buffer_slice.get_mapped_range();

diff --git a/player/src/bin/play.rs b/player/src/bin/play.rs
@@ -134,7 +134,9 @@ fn main() {
         }
 
         unsafe { global.device_stop_graphics_debugger_capture(device) };
-        global.device_poll(device, wgt::PollType::wait()).unwrap();
+        global
+            .device_poll(device, wgt::PollType::wait_indefinitely())
+            .unwrap();
     }
     #[cfg(feature = "winit")]
     {
@@ -227,7 +229,9 @@ fn main() {
                     },
                     Event::LoopExiting => {
                         log::info!("Closing");
-                        global.device_poll(device, wgt::PollType::wait()).unwrap();
+                        global
+                            .device_poll(device, wgt::PollType::wait_indefinitely())
+                            .unwrap();
                     }
                     _ => {}
                 }

diff --git a/player/tests/player/main.rs b/player/tests/player/main.rs
@@ -136,7 +136,13 @@ impl Test<'_> {
 
         println!("\t\t\tWaiting...");
         global
-            .device_poll(device_id, wgt::PollType::wait())
+            .device_poll(
+                device_id,
+                wgt::PollType::Wait {
+                    submission_index: None,
+                    timeout: Some(std::time::Duration::from_secs(1)), // Tests really shouldn't need longer than that!
+                },
+            )
             .unwrap();
 
         for expect in self.expectations {

diff --git a/tests/src/image.rs b/tests/src/image.rs
@@ -577,7 +577,7 @@ impl ReadbackBuffers {
     ) -> Vec<u8> {
         let buffer_slice = buffer.slice(..);
         buffer_slice.map_async(MapMode::Read, |_| ());
-        ctx.async_poll(PollType::wait()).await.unwrap();
+        ctx.async_poll(PollType::wait_indefinitely()).await.unwrap();
         let (block_width, block_height) = self.texture_format.block_dimensions();
         let expected_bytes_per_row = (self.texture_width / block_width)
             * self.texture_format.block_copy_size(aspect).unwrap_or(4);

diff --git a/tests/tests/wgpu-gpu/bgra8unorm_storage.rs b/tests/tests/wgpu-gpu/bgra8unorm_storage.rs
@@ -146,7 +146,9 @@ static BGRA8_UNORM_STORAGE: GpuTestConfiguration = GpuTestConfiguration::new()
 
         let buffer_slice = readback_buffer.slice(..);
         buffer_slice.map_async(wgpu::MapMode::Read, Result::unwrap);
-        ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+        ctx.async_poll(wgpu::PollType::wait_indefinitely())
+            .await
+            .unwrap();
 
         {
             let texels = buffer_slice.get_mapped_range();

diff --git a/tests/tests/wgpu-gpu/bind_groups.rs b/tests/tests/wgpu-gpu/bind_groups.rs
@@ -125,7 +125,7 @@ fn multiple_bindings_with_differing_sizes(ctx: TestingContext) {
     ctx.queue.write_buffer(&buffer, 0, &data);
     ctx.queue.submit(Some(encoder.finish()));
 
-    ctx.device.poll(PollType::Wait).unwrap();
+    ctx.device.poll(PollType::wait_indefinitely()).unwrap();
 }
 
 /// Test `descriptor` against a bind group layout that requires non-filtering sampler.

diff --git a/tests/tests/wgpu-gpu/binding_array/buffers.rs b/tests/tests/wgpu-gpu/binding_array/buffers.rs
@@ -265,7 +265,7 @@ async fn binding_array_buffers(
     let slice = readback_buffer.slice(..);
     slice.map_async(MapMode::Read, |_| {});
 
-    ctx.device.poll(PollType::Wait).unwrap();
+    ctx.device.poll(PollType::wait_indefinitely()).unwrap();
 
     let data = slice.get_mapped_range();
 

diff --git a/tests/tests/wgpu-gpu/binding_array/samplers.rs b/tests/tests/wgpu-gpu/binding_array/samplers.rs
@@ -251,7 +251,7 @@ async fn binding_array_samplers(ctx: TestingContext, partially_bound: bool) {
     ctx.queue.submit(Some(encoder.finish()));
 
     readback_buffer.slice(..).map_async(MapMode::Read, |_| {});
-    ctx.device.poll(PollType::Wait).unwrap();
+    ctx.device.poll(PollType::wait_indefinitely()).unwrap();
 
     let readback_buffer_slice = readback_buffer.slice(..).get_mapped_range();
 

diff --git a/tests/tests/wgpu-gpu/buffer.rs b/tests/tests/wgpu-gpu/buffer.rs
@@ -27,7 +27,9 @@ async fn test_empty_buffer_range(ctx: &TestingContext, buffer_size: u64, label:
         b0.slice(0..0)
             .map_async(wgpu::MapMode::Read, Result::unwrap);
 
-        ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+        ctx.async_poll(wgpu::PollType::wait_indefinitely())
+            .await
+            .unwrap();
 
         {
             let view = b0.slice(0..0).get_mapped_range();
@@ -61,7 +63,9 @@ async fn test_empty_buffer_range(ctx: &TestingContext, buffer_size: u64, label:
             b0.slice(0..0)
                 .map_async(wgpu::MapMode::Write, Result::unwrap);
 
-            ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+            ctx.async_poll(wgpu::PollType::wait_indefinitely())
+                .await
+                .unwrap();
 
             //{
             //    let view = b0.slice(0..0).get_mapped_range_mut();
@@ -90,7 +94,9 @@ async fn test_empty_buffer_range(ctx: &TestingContext, buffer_size: u64, label:
 
     b1.unmap();
 
-    ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+    ctx.async_poll(wgpu::PollType::wait_indefinitely())
+        .await
+        .unwrap();
 }
 
 #[gpu_test]
@@ -135,7 +141,9 @@ static MAP_OFFSET: GpuTestConfiguration = GpuTestConfiguration::new()
                 result.unwrap();
             });
 
-        ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+        ctx.async_poll(wgpu::PollType::wait_indefinitely())
+            .await
+            .unwrap();
 
         {
             let slice = write_buf.slice(32..48);
@@ -159,7 +167,9 @@ static MAP_OFFSET: GpuTestConfiguration = GpuTestConfiguration::new()
             .slice(..)
             .map_async(wgpu::MapMode::Read, Result::unwrap);
 
-        ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+        ctx.async_poll(wgpu::PollType::wait_indefinitely())
+            .await
+            .unwrap();
 
         let slice = read_buf.slice(..);
         let view = slice.get_mapped_range();

diff --git a/tests/tests/wgpu-gpu/buffer_usages.rs b/tests/tests/wgpu-gpu/buffer_usages.rs
@@ -155,7 +155,9 @@ async fn map_test(
         buffer.destroy();
     }
 
-    ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+    ctx.async_poll(wgpu::PollType::wait_indefinitely())
+        .await
+        .unwrap();
 
     if !before_unmap && !before_destroy {
         {

diff --git a/tests/tests/wgpu-gpu/clip_distances.rs b/tests/tests/wgpu-gpu/clip_distances.rs
@@ -123,7 +123,9 @@ async fn clip_distances(ctx: TestingContext) {
     ctx.queue.submit([encoder.finish()]);
     let slice = readback_buffer.slice(..);
     slice.map_async(wgpu::MapMode::Read, |_| ());
-    ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+    ctx.async_poll(wgpu::PollType::wait_indefinitely())
+        .await
+        .unwrap();
     let data: &[u8] = &slice.get_mapped_range();
 
     // We should have filled the upper sector of the texture. Verify that this is the case.

diff --git a/tests/tests/wgpu-gpu/cloneable_types.rs b/tests/tests/wgpu-gpu/cloneable_types.rs
@@ -40,7 +40,9 @@ fn cloneable_buffers(ctx: TestingContext) {
         assert_eq!(&*data, &cloned_buffer_contents);
     });
 
-    ctx.device.poll(wgpu::PollType::Wait).unwrap();
+    ctx.device
+        .poll(wgpu::PollType::wait_indefinitely())
+        .unwrap();
 
     let data = buffer.slice(..).get_mapped_range();