Device valid

CHANGELOG.md

@@ -101,6 +101,7 @@ By @wumpf in [#4147](https://github.com/gfx-rs/wgpu/pull/4147)
 - `wgpu::CreateSurfaceError` and `wgpu::RequestDeviceError` now give details of the failure, but no longer implement `PartialEq` and cannot be constructed. By @kpreid in [#4066](https://github.com/gfx-rs/wgpu/pull/4066) and [#4145](https://github.com/gfx-rs/wgpu/pull/4145)
 - Make `WGPU_POWER_PREF=none` a valid value. By @fornwall in [4076](https://github.com/gfx-rs/wgpu/pull/4076)
 - Support dual source blending in OpenGL ES, Metal, Vulkan & DX12. By @freqmod in [4022](https://github.com/gfx-rs/wgpu/pull/4022)
+- Add stub support for "lose the device" and device validity. By @bradwerth in [4163](https://github.com/gfx-rs/wgpu/pull/4163)
 
 #### Vulkan
 
@@ -117,6 +118,10 @@ By @wumpf in [#4147](https://github.com/gfx-rs/wgpu/pull/4147)
 
 - Support for timestamp queries on encoders and passes. By @wumpf in [#4008](https://github.com/gfx-rs/wgpu/pull/4008)
 
+#### Metal
+
+- Support for timestamp queries on encoders and passes. By @wumpf in [#4008](https://github.com/gfx-rs/wgpu/pull/4008)
+
 ### Bug Fixes
 
 #### General

tests/tests/device.rs

@@ -1,6 +1,6 @@
 use wasm_bindgen_test::*;
 
-use wgpu_test::{initialize_test, FailureCase, TestParameters};
+use wgpu_test::{fail, initialize_test, FailureCase, TestParameters};
 
 #[test]
 #[wasm_bindgen_test]
@@ -91,3 +91,181 @@ async fn request_device_error_message() {
     }
     assert!(device_error.contains(expected), "{device_error}");
 }
+
+#[test]
+fn device_lose_then_more() {
+    // This is a test of device behavior after "lose the device". Specifically, all operations
+    // should trigger errors. To test this, it calls an explicit function to lose the device,
+    // which is not part of normal use and ideally wouldn't be exposed at all.
+    //
+    // TODO: Figure out how to make device.lose a private function only available to the test
+    // harness.
+    //
+    // On DX12 this test fails with a validation error in the very artifical actions taken
+    // after lose the device. The error is "ID3D12CommandAllocator::Reset: The command
+    // allocator cannot be reset because a command list is currently being recorded with the
+    // allocator." That may indicate that DX12 doesn't like opened command buffers staying
+    // open even after they return an error. For now, this test is skipped on DX12.
+    initialize_test(
+        TestParameters::default()
+            .features(wgpu::Features::CLEAR_TEXTURE)
+            .skip(FailureCase::backend(wgpu::Backends::DX12)),
+        |ctx| {
+            // Create some resources on the device that we will attempt to use *after* losing the
+            // device.
+
+            // Create a 512 x 512 2D texture, and a target view of it.
+            let texture_extent = wgpu::Extent3d {
+                width: 512,
+                height: 512,
+                depth_or_array_layers: 1,
+            };
+            let texture_for_view = ctx.device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size: texture_extent,
+                mip_level_count: 2,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rg8Uint,
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+                view_formats: &[],
+            });
+            let target_view = texture_for_view.create_view(&wgpu::TextureViewDescriptor::default());
+
+            let texture_for_write = ctx.device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size: texture_extent,
+                mip_level_count: 2,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rg8Uint,
+                usage: wgpu::TextureUsages::COPY_DST,
+                view_formats: &[],
+            });
+
+            // Create some buffers.
+            let buffer_source = ctx.device.create_buffer(&wgpu::BufferDescriptor {
+                label: None,
+                size: 256,
+                usage: wgpu::BufferUsages::MAP_WRITE | wgpu::BufferUsages::COPY_SRC,
+                mapped_at_creation: false,
+            });
+            let buffer_dest = ctx.device.create_buffer(&wgpu::BufferDescriptor {
+                label: None,
+                size: 256,
+                usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            });
+
+            // Create some command encoders.
+            let mut encoder_for_clear = ctx
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+
+            let mut encoder_for_compute_pass = ctx
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+
+            let mut encoder_for_render_pass = ctx
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+
+            let mut encoder_for_buffer_buffer_copy = ctx
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+
+            let mut encoder_for_buffer_texture_copy = ctx
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+
+            // Lose the device. This will cause all other requests to return some variation of a
+            // device invalid error.
+            ctx.device.lose();
+
+            // TODO: change these fail calls to check for the specific errors which indicate that
+            // the device is not valid.
+
+            // Creating a texture should fail.
+            fail(&ctx.device, || {
+                ctx.device.create_texture(&wgpu::TextureDescriptor {
+                    label: None,
+                    size: wgpu::Extent3d {
+                        width: 512,
+                        height: 512,
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 2,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: wgpu::TextureFormat::Rg8Uint,
+                    usage: wgpu::TextureUsages::COPY_SRC,
+                    view_formats: &[],
+                });
+            });
+
+            // Texture clear should fail.
+            fail(&ctx.device, || {
+                encoder_for_clear.clear_texture(
+                    &texture_for_write,
+                    &wgpu::ImageSubresourceRange {
+                        aspect: wgpu::TextureAspect::All,
+                        base_mip_level: 0,
+                        mip_level_count: None,
+                        base_array_layer: 0,
+                        array_layer_count: None,
+                    },
+                );
+            });
+
+            // Creating a compute pass should fail.
+            fail(&ctx.device, || {
+                encoder_for_compute_pass.begin_compute_pass(&wgpu::ComputePassDescriptor {
+                    label: None,
+                    timestamp_writes: None,
+                });
+            });
+
+            // Creating a render pass should fail.
+            fail(&ctx.device, || {
+                encoder_for_render_pass.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    label: None,
+                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                        ops: wgpu::Operations::default(),
+                        resolve_target: None,
+                        view: &target_view,
+                    })],
+                    depth_stencil_attachment: None,
+                    timestamp_writes: None,
+                    occlusion_query_set: None,
+                });
+            });
+
+            // Copying a buffer to a buffer should fail.
+            fail(&ctx.device, || {
+                encoder_for_buffer_buffer_copy.copy_buffer_to_buffer(
+                    &buffer_source,
+                    0,
+                    &buffer_dest,
+                    0,
+                    256,
+                );
+            });
+
+            // Copying a buffer to a texture should fail.
+            fail(&ctx.device, || {
+                encoder_for_buffer_texture_copy.copy_buffer_to_texture(
+                    wgpu::ImageCopyBuffer {
+                        buffer: &buffer_source,
+                        layout: wgpu::ImageDataLayout {
+                            offset: 0,
+                            bytes_per_row: Some(4),
+                            rows_per_image: None,
+                        },
+                    },
+                    texture_for_write.as_image_copy(),
+                    texture_extent,
+                );
+            });
+        },
+    )
+}

wgpu-core/src/command/clear.rs

@@ -219,6 +219,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         }
 
         let device = &device_guard[cmd_buf.device_id.value];
+        if !device.is_valid() {
+            return Err(ClearError::InvalidDevice(cmd_buf.device_id.value.0));
+        }
 
         clear_texture(
             &*texture_guard,

wgpu-core/src/command/compute.rs

@@ -16,6 +16,7 @@ use crate::{
     hal_api::HalApi,
     hub::Token,
     id,
+    id::DeviceId,
     identity::GlobalIdentityHandlerFactory,
     init_tracker::MemoryInitKind,
     pipeline,
@@ -193,6 +194,8 @@ pub enum ComputePassErrorInner {
     Encoder(#[from] CommandEncoderError),
     #[error("Bind group {0:?} is invalid")]
     InvalidBindGroup(id::BindGroupId),
+    #[error("Device {0:?} is invalid")]
+    InvalidDevice(DeviceId),
     #[error("Bind group index {index} is greater than the device's requested `max_bind_group` limit {max}")]
     BindGroupIndexOutOfRange { index: u32, max: u32 },
     #[error("Compute pipeline {0:?} is invalid")]
@@ -390,6 +393,12 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let raw = cmd_buf.encoder.open();
 
         let device = &device_guard[cmd_buf.device_id.value];
+        if !device.is_valid() {
+            return Err(ComputePassErrorInner::InvalidDevice(
+                cmd_buf.device_id.value.0,
+            ))
+            .map_pass_err(init_scope);
+        }
 
         #[cfg(feature = "trace")]
         if let Some(ref mut list) = cmd_buf.commands {

wgpu-core/src/command/render.rs

@@ -18,6 +18,7 @@ use crate::{
     hal_api::HalApi,
     hub::Token,
     id,
+    id::DeviceId,
     identity::GlobalIdentityHandlerFactory,
     init_tracker::{MemoryInitKind, TextureInitRange, TextureInitTrackerAction},
     pipeline::{self, PipelineFlags},
@@ -523,6 +524,8 @@ pub enum RenderPassErrorInner {
     ColorAttachment(#[from] ColorAttachmentError),
     #[error(transparent)]
     Encoder(#[from] CommandEncoderError),
+    #[error("Device {0:?} is invalid")]
+    InvalidDevice(DeviceId),
     #[error("Attachment texture view {0:?} is invalid")]
     InvalidAttachment(id::TextureViewId),
     #[error("The format of the depth-stencil attachment ({0:?}) is not a depth-stencil format")]
@@ -1346,6 +1349,12 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             }
 
             let device = &device_guard[cmd_buf.device_id.value];
+            if !device.is_valid() {
+                return Err(RenderPassErrorInner::InvalidDevice(
+                    cmd_buf.device_id.value.0,
+                ))
+                .map_pass_err(init_scope);
+            }
             cmd_buf.encoder.open_pass(base.label);
 
             let (bundle_guard, mut token) = hub.render_bundles.read(&mut token);

wgpu-core/src/command/transfer.rs

@@ -8,7 +8,7 @@ use crate::{
     global::Global,
     hal_api::HalApi,
     hub::Token,
-    id::{BufferId, CommandEncoderId, TextureId, Valid},
+    id::{BufferId, CommandEncoderId, DeviceId, TextureId, Valid},
     identity::GlobalIdentityHandlerFactory,
     init_tracker::{
         has_copy_partial_init_tracker_coverage, MemoryInitKind, TextureInitRange,
@@ -40,6 +40,8 @@ pub enum CopySide {
 #[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub enum TransferError {
+    #[error("Device {0:?} is invalid")]
+    InvalidDevice(DeviceId),
     #[error("Buffer {0:?} is invalid or destroyed")]
     InvalidBuffer(BufferId),
     #[error("Texture {0:?} is invalid or destroyed")]
@@ -569,6 +571,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (buffer_guard, _) = hub.buffers.read(&mut token);
 
         let device = &device_guard[cmd_buf.device_id.value];
+        if !device.is_valid() {
+            return Err(TransferError::InvalidDevice(cmd_buf.device_id.value.0).into());
+        }
 
         #[cfg(feature = "trace")]
         if let Some(ref mut list) = cmd_buf.commands {
@@ -714,6 +719,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (texture_guard, _) = hub.textures.read(&mut token);
 
         let device = &device_guard[cmd_buf.device_id.value];
+        if !device.is_valid() {
+            return Err(TransferError::InvalidDevice(cmd_buf.device_id.value.0).into());
+        }
 
         #[cfg(feature = "trace")]
         if let Some(ref mut list) = cmd_buf.commands {
@@ -858,6 +866,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (texture_guard, _) = hub.textures.read(&mut token);
 
         let device = &device_guard[cmd_buf.device_id.value];
+        if !device.is_valid() {
+            return Err(TransferError::InvalidDevice(cmd_buf.device_id.value.0).into());
+        }
 
         #[cfg(feature = "trace")]
         if let Some(ref mut list) = cmd_buf.commands {
@@ -1020,6 +1031,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (texture_guard, _) = hub.textures.read(&mut token);
 
         let device = &device_guard[cmd_buf.device_id.value];
+        if !device.is_valid() {
+            return Err(TransferError::InvalidDevice(cmd_buf.device_id.value.0).into());
+        }
 
         #[cfg(feature = "trace")]
         if let Some(ref mut list) = cmd_buf.commands {