diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index dfa2c7239..c0b873a5e 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -4003,7 +4003,11 @@ impl Renderer { cull.end(&self.device, &mut encoder); } if let Some(timer) = &mut self.gpu_timer { - timer.end(&mut encoder); + timer.end( + &self.device, + &mut encoder, + (&view_target, self.config.format.remove_srgb_suffix()), + ); } let readback = self.screenshot.take().and_then(|path| { // The copy and PNG writer both assume 8-bit pixels; a float surface would make @@ -4034,7 +4038,7 @@ impl Renderer { cull.submitted(); } if let Some(timer) = &mut self.gpu_timer { - timer.submitted(); + timer.submitted(&self.queue); timer.collect(&self.device, &mut self.gpu_times); } if let Some((path, buffer)) = readback { diff --git a/crates/horizon-client/src/gfx/timing.rs b/crates/horizon-client/src/gfx/timing.rs index 8f8eee6ee..5fc566fe7 100644 --- a/crates/horizon-client/src/gfx/timing.rs +++ b/crates/horizon-client/src/gfx/timing.rs @@ -1,18 +1,35 @@ //! GPU frame time from timestamp queries, read back a few frames late so the //! CPU never waits for it. Frames whose readback slot is still busy go untimed. //! -//! Where the GPU can only time pass boundaries (Apple GPUs on Metal), the -//! frame is bracketed by two one-thread compute passes that write the -//! timestamps (Metal leaves an empty pass's timestamps at zero). +//! Where the GPU can only time pass boundaries (Apple GPUs on Metal), a +//! one-thread compute pass stamps the frame's start, and a render pass over +//! the frame's target that shades one pixel with every write masked stamps +//! its end (Metal leaves the timestamps of a pass that does nothing at zero). +//! A pass that loads the target runs after every pass that draws into it; a +//! compute pass, which depends on nothing, ran alongside them. Metal also +//! resolves timestamps without waiting for the passes that write them, so +//! they are resolved in a later frame, once the GPU has finished this one. +//! Resolved in the frame itself, the end was mostly the one an earlier frame +//! left in the query, and frames read about 0.01 ms. use std::sync::{ Arc, atomic::{AtomicU8, Ordering}, }; -const SLOTS: usize = 4; +/// Frames in flight at once; on Metal a slot is busy for about five frames. +const SLOTS: usize = 8; +/// Each slot's timestamps have their own queries and resolve range. +const RESOLVE_STRIDE: u64 = wgpu::QUERY_RESOLVE_BUFFER_ALIGNMENT; +/// The frame's target and its format. +pub type Target<'a> = (&'a wgpu::TextureView, wgpu::TextureFormat); const FREE: u8 = 0; -const PENDING: u8 = 1; -const MAPPED: u8 = 2; +/// Its frame is submitted; with markers, until the GPU has finished it. +const RUNNING: u8 = 1; +/// Its frame is finished: its timestamps can be resolved. +const DONE: u8 = 2; +/// Resolved and on its way back. +const PENDING: u8 = 3; +const MAPPED: u8 = 4; struct Slot { buffer: wgpu::Buffer, @@ -27,10 +44,29 @@ pub struct GpuTimer { current: Option, next: usize, period_ns: f32, - /// Timestamps between commands, or else this pass's boundaries. - marker: Option, + /// Timestamps between commands, or else these passes' boundaries. + markers: Option, + /// Slots resolved in this frame's commands, read back once it is submitted. + resolved: Vec, } +/// The marker passes: the start's compute pipeline, and the end's shader and +/// pipeline, for the target format it was made for. +struct Markers { + module: wgpu::ShaderModule, + start: wgpu::ComputePipeline, + end: Option<(wgpu::TextureFormat, wgpu::RenderPipeline)>, +} + +/// The start's one thread; the end's triangle over the whole target (the +/// pass's scissor keeps one pixel), shading nothing it writes. +const MARKER: &str = + "@vertex fn cover(@builtin(vertex_index) i: u32) -> @builtin(position) vec4 { + return vec4(f32(i & 1u) * 4.0 - 1.0, f32(i >> 1u) * 4.0 - 1.0, 0.0, 1.0); +} +@fragment fn nothing() -> @location(0) vec4 { return vec4(0.0); } +@compute @workgroup_size(1) fn mark() {}"; + impl GpuTimer { /// The features timing uses that the adapter has (none: no timing). pub fn features(adapter: &wgpu::Adapter) -> wgpu::Features { @@ -44,11 +80,11 @@ impl GpuTimer { let queries = device.create_query_set(&wgpu::QuerySetDescriptor { label: Some("Frame timestamps"), ty: wgpu::QueryType::Timestamp, - count: 2, + count: 2 * SLOTS as u32, }); let resolve = device.create_buffer(&wgpu::BufferDescriptor { label: Some("Frame timestamp resolve"), - size: 16, + size: RESOLVE_STRIDE * SLOTS as u64, usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC, mapped_at_creation: false, }); @@ -70,42 +106,43 @@ impl GpuTimer { current: None, next: 0, period_ns: queue.get_timestamp_period(), - marker: (!device + markers: (!device .features() .contains(wgpu::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS)) .then(|| { let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Frame timestamp"), - source: wgpu::ShaderSource::Wgsl( - "@compute @workgroup_size(1) fn mark() {}".into(), - ), + source: wgpu::ShaderSource::Wgsl(MARKER.into()), }); - device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some("Frame timestamp"), - layout: None, - module: &module, - entry_point: Some("mark"), - compilation_options: Default::default(), - cache: None, - }) + Markers { + start: device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("Frame timestamp"), + layout: None, + module: &module, + entry_point: Some("mark"), + compilation_options: Default::default(), + cache: None, + }), + module, + end: None, + } }), + resolved: Vec::new(), }) } pub fn begin(&mut self, encoder: &mut wgpu::CommandEncoder) { + if self.markers.is_some() { + for slot in 0..SLOTS { + if self.slots[slot].state.load(Ordering::Acquire) == DONE { + self.resolve(encoder, slot); + } + } + } let slot = self.next; self.current = (self.slots[slot].state.load(Ordering::Acquire) == FREE).then_some(slot); - if self.current.is_some() { - self.stamp(encoder, 0); - } - } - pub fn end(&mut self, encoder: &mut wgpu::CommandEncoder) { let Some(slot) = self.current else { return }; - self.stamp(encoder, 1); - encoder.resolve_query_set(&self.queries, 0..2, &self.resolve, 0); - encoder.copy_buffer_to_buffer(&self.resolve, 0, &self.slots[slot].buffer, 0, 16); - } - fn stamp(&self, encoder: &mut wgpu::CommandEncoder, index: u32) { - let Some(marker) = &self.marker else { + let index = 2 * slot as u32; + let Some(markers) = &self.markers else { encoder.write_timestamp(&self.queries, index); return; }; @@ -113,29 +150,85 @@ impl GpuTimer { label: Some("Frame timestamp"), timestamp_writes: Some(wgpu::ComputePassTimestampWrites { query_set: &self.queries, - beginning_of_pass_write_index: (index == 0).then_some(0), - end_of_pass_write_index: (index == 1).then_some(1), + beginning_of_pass_write_index: Some(index), + end_of_pass_write_index: None, }), }); - pass.set_pipeline(marker); + pass.set_pipeline(&markers.start); pass.dispatch_workgroups(1, 1, 1); } - /// After the frame's submission: start reading its timestamps back. - pub fn submitted(&mut self) { + /// After the frame's last pass into `target` (the frame's own, of `format`). + pub fn end( + &mut self, + device: &wgpu::Device, + encoder: &mut wgpu::CommandEncoder, + (target, format): Target, + ) { + let Some(slot) = self.current else { return }; + let index = 2 * slot as u32 + 1; + let Some(markers) = &mut self.markers else { + encoder.write_timestamp(&self.queries, index); + self.resolve(encoder, slot); + return; + }; + if markers.end.as_ref().is_none_or(|(f, _)| *f != format) { + markers.end = Some((format, end_pipeline(device, &markers.module, format))); + } + let (_, pipeline) = markers.end.as_ref().expect("made above"); + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Frame timestamp"), + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: target, + depth_slice: None, + resolve_target: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }, + })], + timestamp_writes: Some(wgpu::RenderPassTimestampWrites { + query_set: &self.queries, + beginning_of_pass_write_index: None, + end_of_pass_write_index: Some(index), + }), + ..Default::default() + }); + pass.set_pipeline(pipeline); + pass.set_scissor_rect(0, 0, 1, 1); + pass.draw(0..3, 0..1); + } + /// Copy `slot`'s timestamps to its readback buffer. + fn resolve(&mut self, encoder: &mut wgpu::CommandEncoder, slot: usize) { + let (first, at) = (2 * slot as u32, RESOLVE_STRIDE * slot as u64); + encoder.resolve_query_set(&self.queries, first..first + 2, &self.resolve, at); + encoder.copy_buffer_to_buffer(&self.resolve, at, &self.slots[slot].buffer, 0, 16); + self.slots[slot].state.store(RUNNING, Ordering::Release); + self.resolved.push(slot); + } + /// After the frame's submission: start reading back what it resolved, + /// and with markers, wait for the GPU to finish the frame it timed. + pub fn submitted(&mut self, queue: &wgpu::Queue) { + for slot in self.resolved.drain(..) { + let state = self.slots[slot].state.clone(); + state.store(PENDING, Ordering::Release); + self.slots[slot] + .buffer + .slice(..) + .map_async(wgpu::MapMode::Read, move |result| { + state.store( + if result.is_ok() { MAPPED } else { FREE }, + Ordering::Release, + ); + }); + } let Some(slot) = self.current.take() else { return; }; - let state = self.slots[slot].state.clone(); - state.store(PENDING, Ordering::Release); - self.slots[slot] - .buffer - .slice(..) - .map_async(wgpu::MapMode::Read, move |result| { - state.store( - if result.is_ok() { MAPPED } else { FREE }, - Ordering::Release, - ); - }); + if self.markers.is_some() { + let state = self.slots[slot].state.clone(); + state.store(RUNNING, Ordering::Release); + queue.on_submitted_work_done(move || state.store(DONE, Ordering::Release)); + } self.next = (slot + 1) % SLOTS; } /// GPU milliseconds of frames whose timestamps have arrived, oldest first. @@ -149,11 +242,46 @@ impl GpuTimer { if let Ok(data) = slot.buffer.slice(..).get_mapped_range() { // Read unaligned: the mapping isn't guaranteed to be 8-byte aligned. let stamps: [u64; 2] = bytemuck::pod_read_unaligned(&data[..16]); - let ticks = stamps[1].saturating_sub(stamps[0]); - out.push((ticks as f64 * f64::from(self.period_ns) / 1e6) as f32); + // A start marker that ran late (rare on Metal) leaves the frame untimed. + if let Some(ticks) = stamps[1].checked_sub(stamps[0]) { + out.push((ticks as f64 * f64::from(self.period_ns) / 1e6) as f32); + } } slot.buffer.unmap(); slot.state.store(FREE, Ordering::Release); } } } + +/// The end marker's pipeline for a `format` target, every write masked. +fn end_pipeline( + device: &wgpu::Device, + module: &wgpu::ShaderModule, + format: wgpu::TextureFormat, +) -> wgpu::RenderPipeline { + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Frame timestamp"), + layout: None, + vertex: wgpu::VertexState { + module, + entry_point: Some("cover"), + compilation_options: Default::default(), + buffers: &[], + }, + primitive: wgpu::PrimitiveState::default(), + depth_stencil: None, + multisample: wgpu::MultisampleState::default(), + fragment: Some(wgpu::FragmentState { + module, + entry_point: Some("nothing"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format, + blend: None, + write_mask: wgpu::ColorWrites::empty(), + })], + }), + multiview_mask: None, + cache: None, + }) +}