feature: Timestamp queries

CHANGELOG.md

@@ -161,6 +161,15 @@ Some texture format names have changed to get back in line with the spec.
 
 By @cwfitzgerald in [#3671](https://github.com/gfx-rs/wgpu/pull/3671).
 
+#### Pass timestamp queries
+
+Addition of `TimestampWrites` to compute and render passes to allow profiling.
+This brings us in line with the spec.
+
+Added new example to demonstrate the various kinds of timestamps.
+
+By @FL33TW00D & @wumpf in [#3636](https://github.com/gfx-rs/wgpu/pull/3636).
+
 #### Misc Breaking Changes
 
 - Change type of `mip_level_count` and `array_layer_count` (members of `TextureViewDescriptor` and `ImageSubresourceRange`) from `Option<NonZeroU32>` to `Option<u32>`. By @teoxoy in [#3445](https://github.com/gfx-rs/wgpu/pull/3445)

Cargo.toml

@@ -90,7 +90,7 @@ winit = "0.27.1"
 # Metal dependencies
 block = "0.1"
 foreign-types = "0.3"
-metal = "0.24.0"
+metal = "0.25.0"
 objc = "0.2.5"
 core-graphics-types = "0.1"
 

deno_webgpu/command_encoder.rs

@@ -175,6 +175,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
         label: label.map(Cow::from),
         color_attachments: Cow::from(color_attachments),
         depth_stencil_attachment: processed_depth_stencil_attachment.as_ref(),
+        timestamp_writes: None,
     };
 
     let render_pass = wgpu_core::command::RenderPass::new(command_encoder_resource.1, &descriptor);
@@ -200,6 +201,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
 
     let descriptor = wgpu_core::command::ComputePassDescriptor {
         label: label.map(Cow::from),
+        timestamp_writes: None,
     };
 
     let compute_pass =

deno_webgpu/error.rs

@@ -104,7 +104,9 @@ impl From<DeviceError> for WebGpuError {
         match err {
             DeviceError::Lost => WebGpuError::Lost,
             DeviceError::OutOfMemory => WebGpuError::OutOfMemory,
-            DeviceError::Invalid => WebGpuError::Validation(fmt_err(&err)),
+            DeviceError::ResourceCreationFailed | DeviceError::Invalid => {
+                WebGpuError::Validation(fmt_err(&err))
+            }
         }
     }
 }

player/src/lib.rs

@@ -119,20 +119,29 @@ impl GlobalPlay for wgc::hub::Global<IdentityPassThroughFactory> {
                 trace::Command::InsertDebugMarker(marker) => self
                     .command_encoder_insert_debug_marker::<A>(encoder, &marker)
                     .unwrap(),
-                trace::Command::RunComputePass { base } => {
-                    self.command_encoder_run_compute_pass_impl::<A>(encoder, base.as_ref())
-                        .unwrap();
+                trace::Command::RunComputePass {
+                    base,
+                    timestamp_writes,
+                } => {
+                    self.command_encoder_run_compute_pass_impl::<A>(
+                        encoder,
+                        base.as_ref(),
+                        timestamp_writes.as_ref(),
+                    )
+                    .unwrap();
                 }
                 trace::Command::RunRenderPass {
                     base,
                     target_colors,
                     target_depth_stencil,
+                    timestamp_writes,
                 } => {
                     self.command_encoder_run_render_pass_impl::<A>(
                         encoder,
                         base.as_ref(),
                         &target_colors,
                         target_depth_stencil.as_ref(),
+                        timestamp_writes.as_ref(),
                     )
                     .unwrap();
                 }

wgpu-core/src/command/clear.rs

@@ -448,6 +448,7 @@ fn clear_texture_via_render_passes<A: hal::Api>(
                     color_attachments,
                     depth_stencil_attachment,
                     multiview: None,
+                    timestamp_writes: None,
                 });
                 encoder.end_render_pass();
             }

wgpu-core/src/command/compute.rs

@@ -22,6 +22,11 @@ use crate::{
 };
 
 use hal::CommandEncoder as _;
+#[cfg(any(feature = "serial-pass", feature = "replay"))]
+use serde::Deserialize;
+#[cfg(any(feature = "serial-pass", feature = "trace"))]
+use serde::Serialize;
+
 use thiserror::Error;
 
 use std::{fmt, mem, str};
@@ -90,6 +95,7 @@ pub enum ComputeCommand {
 pub struct ComputePass {
     base: BasePass<ComputeCommand>,
     parent_id: id::CommandEncoderId,
+    timestamp_writes: Option<ComputePassTimestampWrites>,
 
     // Resource binding dedupe state.
     #[cfg_attr(feature = "serial-pass", serde(skip))]
@@ -103,6 +109,7 @@ impl ComputePass {
         Self {
             base: BasePass::new(&desc.label),
             parent_id,
+            timestamp_writes: desc.timestamp_writes.cloned(),
 
             current_bind_groups: BindGroupStateChange::new(),
             current_pipeline: StateChange::new(),
@@ -115,7 +122,10 @@ impl ComputePass {
 
     #[cfg(feature = "trace")]
     pub fn into_command(self) -> crate::device::trace::Command {
-        crate::device::trace::Command::RunComputePass { base: self.base }
+        crate::device::trace::Command::RunComputePass {
+            base: self.base,
+            timestamp_writes: self.timestamp_writes,
+        }
     }
 }
 
@@ -131,9 +141,25 @@ impl fmt::Debug for ComputePass {
     }
 }
 
+/// Describes the writing of timestamp values in a compute pass.
+#[repr(C)]
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(any(feature = "serial-pass", feature = "trace"), derive(Serialize))]
+#[cfg_attr(any(feature = "serial-pass", feature = "replay"), derive(Deserialize))]
+pub struct ComputePassTimestampWrites {
+    /// The query set to write the timestamps to.
+    pub query_set: id::QuerySetId,
+    /// The index of the query at which the start timestamp of the pass is written if any.
+    pub beginning_of_pass_write_index: Option<u32>,
+    /// The index of the query at which the end timestamp of the pass is written if any.
+    pub end_of_pass_write_index: Option<u32>,
+}
+
 #[derive(Clone, Debug, Default)]
 pub struct ComputePassDescriptor<'a> {
     pub label: Label<'a>,
+    /// Defines where and when timestamp values will be written for this pass.
+    pub timestamp_writes: Option<&'a ComputePassTimestampWrites>,
 }
 
 #[derive(Clone, Debug, Error, Eq, PartialEq)]
@@ -321,14 +347,19 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         encoder_id: id::CommandEncoderId,
         pass: &ComputePass,
     ) -> Result<(), ComputePassError> {
-        self.command_encoder_run_compute_pass_impl::<A>(encoder_id, pass.base.as_ref())
+        self.command_encoder_run_compute_pass_impl::<A>(
+            encoder_id,
+            pass.base.as_ref(),
+            pass.timestamp_writes.as_ref(),
+        )
     }
 
     #[doc(hidden)]
     pub fn command_encoder_run_compute_pass_impl<A: HalApi>(
         &self,
         encoder_id: id::CommandEncoderId,
         base: BasePassRef<ComputeCommand>,
+        timestamp_writes: Option<&ComputePassTimestampWrites>,
     ) -> Result<(), ComputePassError> {
         profiling::scope!("CommandEncoder::run_compute_pass");
         let init_scope = PassErrorScope::Pass(encoder_id);
@@ -354,6 +385,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         if let Some(ref mut list) = cmd_buf.commands {
             list.push(crate::device::trace::Command::RunComputePass {
                 base: BasePass::from_ref(base),
+                timestamp_writes: timestamp_writes.cloned(),
             });
         }
 
@@ -376,6 +408,42 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let mut string_offset = 0;
         let mut active_query = None;
 
+        let timestamp_writes = if let Some(tw) = timestamp_writes {
+            let query_set: &resource::QuerySet<A> = cmd_buf
+                .trackers
+                .query_sets
+                .add_single(&*query_set_guard, tw.query_set)
+                .ok_or(ComputePassErrorInner::InvalidQuerySet(tw.query_set))
+                .map_pass_err(init_scope)?;
+
+            // Unlike in render passes we can't delay resetting the query sets since
+            // there is no auxillary pass.
+            let range = if let (Some(index_a), Some(index_b)) =
+                (tw.beginning_of_pass_write_index, tw.end_of_pass_write_index)
+            {
+                Some(index_a.min(index_b)..index_a.max(index_b) + 1)
+            } else {
+                tw.beginning_of_pass_write_index
+                    .or(tw.end_of_pass_write_index)
+                    .map(|i| i..i + 1)
+            };
+            // Range should always be Some, both values being None should lead to a validation err.r
+            // But no point in erroring over that nuance here!
+            if let Some(range) = range {
+                unsafe {
+                    raw.reset_queries(&query_set.raw, range);
+                }
+            }
+
+            Some(hal::ComputePassTimestampWrites {
+                query_set: &query_set.raw,
+                beginning_of_pass_write_index: tw.beginning_of_pass_write_index,
+                end_of_pass_write_index: tw.end_of_pass_write_index,
+            })
+        } else {
+            None
+        };
+
         cmd_buf.trackers.set_size(
             Some(&*buffer_guard),
             Some(&*texture_guard),
@@ -388,7 +456,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             Some(&*query_set_guard),
         );
 
-        let hal_desc = hal::ComputePassDescriptor { label: base.label };
+        let hal_desc = hal::ComputePassDescriptor {
+            label: base.label,
+            timestamp_writes,
+        };
+
         unsafe {
             raw.begin_compute_pass(&hal_desc);
         }

wgpu-core/src/command/mod.rs

@@ -99,6 +99,7 @@ pub struct CommandBuffer<A: HalApi> {
     pub(crate) trackers: Tracker<A>,
     buffer_memory_init_actions: Vec<BufferInitTrackerAction>,
     texture_memory_actions: CommandBufferTextureMemoryActions,
+    pub(crate) pending_query_resets: QueryResetMap<A>,
     limits: wgt::Limits,
     support_clear_texture: bool,
     #[cfg(feature = "trace")]
@@ -127,6 +128,7 @@ impl<A: HalApi> CommandBuffer<A> {
             trackers: Tracker::new(),
             buffer_memory_init_actions: Default::default(),
             texture_memory_actions: Default::default(),
+            pending_query_resets: QueryResetMap::new(),
             limits,
             support_clear_texture: features.contains(wgt::Features::CLEAR_TEXTURE),
             #[cfg(feature = "trace")]

wgpu-core/src/command/query.rs

@@ -15,7 +15,7 @@ use thiserror::Error;
 use wgt::BufferAddress;
 
 #[derive(Debug)]
-pub(super) struct QueryResetMap<A: hal::Api> {
+pub(crate) struct QueryResetMap<A: hal::Api> {
     map: FastHashMap<Index, (Vec<bool>, Epoch)>,
     _phantom: PhantomData<A>,
 }
@@ -43,12 +43,12 @@ impl<A: hal::Api> QueryResetMap<A> {
     }
 
     pub fn reset_queries(
-        self,
+        &mut self,
         raw_encoder: &mut A::CommandEncoder,
         query_set_storage: &Storage<QuerySet<A>, id::QuerySetId>,
         backend: wgt::Backend,
     ) -> Result<(), id::QuerySetId> {
-        for (query_set_id, (state, epoch)) in self.map.into_iter() {
+        for (query_set_id, (state, epoch)) in self.map.drain() {
             let id = Id::zip(query_set_id, epoch, backend);
             let query_set = query_set_storage.get(id).map_err(|_| id)?;