Support for storing failed commands in traces

Cargo.toml

@@ -142,6 +142,7 @@ libloading = "0.8"
 libm = { version = "0.2.6", default-features = false }
 libtest-mimic = "0.8"
 log = "0.4.21"
+macro_rules_attribute = "0.2"
 nanoserde = "0.2"
 nanorand = { version = "0.8", default-features = false, features = ["wyrand"] }
 noise = "0.9"

deno_webgpu/device.rs

@@ -577,11 +577,8 @@ impl GPUDevice {
       multiview: None,
     };
 
-    let res = wgpu_core::command::RenderBundleEncoder::new(
-      &wgpu_descriptor,
-      self.id,
-      None,
-    );
+    let res =
+      wgpu_core::command::RenderBundleEncoder::new(&wgpu_descriptor, self.id);
     let (encoder, err) = match res {
       Ok(encoder) => (encoder, None),
       Err(e) => (

docs/testing.md

@@ -39,6 +39,7 @@ This is a table of contents, in the form of the repository's directory structure
    - [compile](#wgpu-compile-tests)
    - [dependency](#wgpu-dependency-tests)
    - [gpu](#wgpu-gpu-tests)
+   - [trace](#wgpu-trace-tests)
    - [validation](#wgpu-validation-tests)
 
 And where applicable [unit-tests](#unit-tests)
@@ -101,7 +102,7 @@ There are inputs in `wgsl`, `spirv`, and `glsl`. There are outputs for
 `hlsl`, `spirv`, `wgsl`, `msl`, `glsl`, and naga's internal IR. The tests
 can be configured by a sidecar toml file of the same name as the input file.
 
-This is the goto tool for testing all kinds of codegen and parsing features. 
+This is the goto tool for testing all kinds of codegen and parsing features.
 
 To avoid clutter we generally use the following pattern:
 
@@ -142,7 +143,7 @@ the [wgsl errors](#naga-wgsl-error-tests) tests.
 
 These are tests for the error messages that the `wgsl` frontend
 produces. Additionally you can check that a given validation error
-is produced by the validator from a given `wgsl` snippet. 
+is produced by the validator from a given `wgsl` snippet.
 
 ## `player` Tests
 
@@ -207,14 +208,23 @@ Normal `#[test]`s will not be found in this test crate, as we use a custom harne
 
 See also the [example tests](#example-tests) for additional GPU tests.
 
+## `wgpu` Trace Tests
+
+- Located in: `tests/tests/wgpu_trace.rs`
+- Run with `cargo nextest run --test wgpu_trace`
+- Use the standard `#[test]` harness.
+
+These tests are focused on testing the tracing functionality in `wgpu`.  They
+use the a special `noop` backend which does not connect to a real GPU.
+
 ## `wgpu` Validation Tests
 
 - Located in: `tests/tests/wgpu-validation`
 - Run with `cargo nextest run --test wgpu-validation`
 - Use the standard `#[test]` harness.
 - `wgpu` integration tests, with access to `wgpu_test` helpers.
 
-These tests are focused on testing the validation inside of `wgpu-core`. 
+These tests are focused on testing the validation inside of `wgpu-core`.
 They are written against the `wgpu` API, but are targeting a special `noop`
 backend which does not connect to a real GPU.
 
@@ -230,4 +240,3 @@ does not support those features.
 
 Throughout the codebase we have standard `#[test]`s that test individual
 functions or small parts of the codebase. These don't run on the gpu.
-

player/Cargo.toml

@@ -22,6 +22,7 @@ test = false
 wgpu-types = { workspace = true, features = ["serde", "std"] }
 
 env_logger.workspace = true
+hashbrown.workspace = true
 log.workspace = true
 raw-window-handle.workspace = true
 ron.workspace = true

player/src/bin/play.rs

@@ -5,14 +5,15 @@ fn main() {
     extern crate wgpu_core as wgc;
     extern crate wgpu_types as wgt;
 
-    use player::GlobalPlay as _;
+    use player::Player;
     use wgc::device::trace;
-    use wgpu_core::identity::IdentityManager;
+    use wgpu_core::command::PointerReferences;
 
     use std::{
         fs,
         path::{Path, PathBuf},
         process::exit,
+        sync::Arc,
     };
 
     #[cfg(feature = "winit")]
@@ -52,7 +53,7 @@ fn main() {
 
     log::info!("Loading trace '{trace:?}'");
     let file = fs::File::open(trace).unwrap();
-    let mut actions: Vec<trace::Action> = ron::de::from_reader(file).unwrap();
+    let mut actions: Vec<trace::Action<PointerReferences>> = ron::de::from_reader(file).unwrap();
     actions.reverse(); // allows us to pop from the top
     log::info!("Found {} actions", actions.len());
 
@@ -68,17 +69,14 @@ fn main() {
         .build(&event_loop)
         .unwrap();
 
-    let global =
-        wgc::global::Global::new("player", &wgt::InstanceDescriptor::from_env_or_default());
-    let mut command_encoder_id_manager = IdentityManager::new();
-    let mut command_buffer_id_manager = IdentityManager::new();
+    let instance_desc = wgt::InstanceDescriptor::from_env_or_default();
+    let instance = wgc::instance::Instance::new("player", &instance_desc);
 
     #[cfg(feature = "winit")]
     let surface = unsafe {
-        global.instance_create_surface(
+        instance.create_surface(
             window.display_handle().unwrap().into(),
             window.window_handle().unwrap().into(),
-            Some(wgc::id::Id::zip(0, 1)),
         )
     }
     .unwrap();
@@ -93,50 +91,41 @@ fn main() {
             None => (wgt::Backends::all(), wgt::DeviceDescriptor::default()),
         };
 
-    let adapter = global
-        .request_adapter(
-            &wgc::instance::RequestAdapterOptions {
-                #[cfg(feature = "winit")]
-                compatible_surface: Some(surface),
-                #[cfg(not(feature = "winit"))]
-                compatible_surface: None,
-                ..Default::default()
-            },
-            backends,
-            Some(wgc::id::AdapterId::zip(0, 1)),
-        )
-        .expect("Unable to obtain an adapter");
-
-    let info = global.adapter_get_info(adapter);
+    let adapter = Arc::new(
+        instance
+            .request_adapter(
+                &wgt::RequestAdapterOptions {
+                    #[cfg(feature = "winit")]
+                    compatible_surface: Some(&surface),
+                    #[cfg(not(feature = "winit"))]
+                    compatible_surface: None,
+                    ..Default::default()
+                },
+                backends,
+            )
+            .expect("Unable to obtain an adapter"),
+    );
+
+    let info = adapter.get_info();
     log::info!("Using '{}'", info.name);
 
-    let device = wgc::id::Id::zip(0, 1);
-    let queue = wgc::id::Id::zip(0, 1);
-    let res = global.adapter_request_device(adapter, &device_desc, Some(device), Some(queue));
-    if let Err(e) = res {
-        panic!("{e:?}");
-    }
+    let (device, queue) = adapter
+        .create_device_and_queue(&device_desc, instance_desc.flags)
+        .unwrap();
+
+    let mut player = Player::default();
 
     log::info!("Executing actions");
     #[cfg(not(feature = "winit"))]
     {
-        unsafe { global.device_start_graphics_debugger_capture(device) };
+        unsafe { device.start_graphics_debugger_capture() };
 
         while let Some(action) = actions.pop() {
-            global.process(
-                device,
-                queue,
-                action,
-                &dir,
-                &mut command_encoder_id_manager,
-                &mut command_buffer_id_manager,
-            );
+            player.process(&device, &queue, action, trace::DiskTraceLoader::new(&dir));
         }
 
-        unsafe { global.device_stop_graphics_debugger_capture(device) };
-        global
-            .device_poll(device, wgt::PollType::wait_indefinitely())
-            .unwrap();
+        unsafe { device.stop_graphics_debugger_capture() };
+        device.poll(wgt::PollType::wait_indefinitely()).unwrap();
     }
     #[cfg(feature = "winit")]
     {
@@ -170,32 +159,29 @@ fn main() {
                                         resize_config = Some(config);
                                         target.exit();
                                     } else {
-                                        let error =
-                                            global.surface_configure(surface, device, &config);
+                                        let error = device.configure_surface(&surface, &config);
                                         if let Some(e) = error {
                                             panic!("{e:?}");
                                         }
                                     }
                                 }
-                                Some(trace::Action::Present(id)) => {
+                                Some(trace::Action::Present(_id)) => {
                                     frame_count += 1;
                                     log::debug!("Presenting frame {frame_count}");
-                                    global.surface_present(id).unwrap();
+                                    surface.present().unwrap();
                                     target.exit();
                                 }
-                                Some(trace::Action::DiscardSurfaceTexture(id)) => {
+                                Some(trace::Action::DiscardSurfaceTexture(_id)) => {
                                     log::debug!("Discarding frame {frame_count}");
-                                    global.surface_texture_discard(id).unwrap();
+                                    surface.discard().unwrap();
                                     target.exit();
                                 }
                                 Some(action) => {
-                                    global.process(
-                                        device,
-                                        queue,
+                                    player.process(
+                                        &device,
+                                        &queue,
                                         action,
-                                        &dir,
-                                        &mut command_encoder_id_manager,
-                                        &mut command_buffer_id_manager,
+                                        trace::DiskTraceLoader::new(&dir),
                                     );
                                 }
                                 None => {
@@ -209,7 +195,7 @@ fn main() {
                         }
                         WindowEvent::Resized(_) => {
                             if let Some(config) = resize_config.take() {
-                                let error = global.surface_configure(surface, device, &config);
+                                let error = device.configure_surface(&surface, &config);
                                 if let Some(e) = error {
                                     panic!("{e:?}");
                                 }
@@ -229,9 +215,7 @@ fn main() {
                     },
                     Event::LoopExiting => {
                         log::info!("Closing");
-                        global
-                            .device_poll(device, wgt::PollType::wait_indefinitely())
-                            .unwrap();
+                        device.poll(wgt::PollType::wait_indefinitely()).unwrap();
                     }
                     _ => {}
                 }