Replay traces with pointers as IDs

Author: andyleiserson

Cargo.lock

@@ -527,7 +527,7 @@ 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) => (

deno_webgpu/device.rs

@@ -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/Cargo.toml

@@ -5,18 +5,19 @@ 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::{command::IdReferences, identity::IdentityManager};
+    use wgpu_core::command::PointerReferences;
 
     use std::{
         fs,
         path::{Path, PathBuf},
         process::exit,
+        sync::Arc,
     };
 
-    #[cfg(feature = "winit")]
-    use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
+    //#[cfg(feature = "winit")]
+    //use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
     #[cfg(feature = "winit")]
     use winit::{
         event::KeyEvent,
@@ -52,7 +53,7 @@ fn main() {
 
     log::info!("Loading trace '{trace:?}'");
     let file = fs::File::open(trace).unwrap();
-    let mut actions: Vec<trace::Action<IdReferences>> = 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,11 +69,10 @@ 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(
@@ -82,6 +82,7 @@ fn main() {
         )
     }
     .unwrap();
+    */
 
     let (backends, device_desc) =
         match actions.pop_if(|action| matches!(action, trace::Action::Init { .. })) {
@@ -93,48 +94,43 @@ 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::new();
 
     log::info!("Executing actions");
     #[cfg(not(feature = "winit"))]
     {
-        unsafe { global.device_start_graphics_debugger_capture(device) };
+        //unsafe { global.device_start_graphics_debugger_capture(device) };
 
         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, &dir);
         }
 
-        unsafe { global.device_stop_graphics_debugger_capture(device) };
-        global.device_poll(device, wgt::PollType::wait()).unwrap();
+        //unsafe { global.device_stop_graphics_debugger_capture(device) };
+        let (user_closures, result) = device.poll(wgt::PollType::wait());
+        user_closures.fire();
+        result.unwrap();
     }
     #[cfg(feature = "winit")]
     {
@@ -168,33 +164,28 @@ fn main() {
                                         resize_config = Some(config);
                                         target.exit();
                                     } else {
+                                        /*
                                         let error =
                                             global.surface_configure(surface, device, &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();
+                                    //global.surface_present(id).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();
+                                    //global.surface_texture_discard(id).unwrap();
                                     target.exit();
                                 }
                                 Some(action) => {
-                                    global.process(
-                                        device,
-                                        queue,
-                                        action,
-                                        &dir,
-                                        &mut command_encoder_id_manager,
-                                        &mut command_buffer_id_manager,
-                                    );
+                                    player.process(&device, &queue, action, &dir);
                                 }
                                 None => {
                                     if !done {
@@ -206,12 +197,14 @@ fn main() {
                             }
                         }
                         WindowEvent::Resized(_) => {
+                            /*
                             if let Some(config) = resize_config.take() {
                                 let error = global.surface_configure(surface, device, &config);
                                 if let Some(e) = error {
                                     panic!("{e:?}");
                                 }
                             }
+                            */
                         }
                         WindowEvent::KeyboardInput {
                             event:
@@ -227,7 +220,9 @@ fn main() {
                     },
                     Event::LoopExiting => {
                         log::info!("Closing");
-                        global.device_poll(device, wgt::PollType::wait()).unwrap();
+                        let (user_closures, result) = device.poll(wgt::PollType::wait());
+                        user_closures.fire();
+                        result.unwrap();
                     }
                     _ => {}
                 }