use crate::{Error, Result};
pub const MAX_PASSES: u32 = 8;
#[derive(Debug)]
pub struct StageTimestamps {
set: wgpu::QuerySet,
resolve: wgpu::Buffer,
readback: wgpu::Buffer,
period_ns: f32,
next: core::sync::atomic::AtomicU32,
labels: std::sync::Mutex<Vec<&'static str>>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Span {
pub label: &'static str,
pub ms: f64,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Spans {
pub spans: Vec<Span>,
pub period_ns: f64,
pub complete: bool,
}
impl Spans {
#[must_use]
pub fn total_ms(&self) -> f64 {
self.spans.iter().map(|s| s.ms).sum()
}
}
impl StageTimestamps {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Result<Self> {
if !device.features().contains(wgpu::Features::TIMESTAMP_QUERY) {
return Err(Error::TimestampsUnsupported);
}
let period_ns = queue.get_timestamp_period();
if !matches!(
period_ns.partial_cmp(&0.0),
Some(core::cmp::Ordering::Greater)
) {
return Err(Error::TimestampsUnsupported);
}
let count = MAX_PASSES * 2;
let bytes = u64::from(count) * 8;
Ok(Self {
set: device.create_query_set(&wgpu::QuerySetDescriptor {
label: Some("isomesh stage timestamps"),
ty: wgpu::QueryType::Timestamp,
count,
}),
resolve: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh timestamp resolve"),
size: bytes,
usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
}),
readback: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh timestamp readback"),
size: bytes,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}),
period_ns,
next: core::sync::atomic::AtomicU32::new(0),
labels: std::sync::Mutex::new(Vec::new()),
})
}
pub fn writes(&self, label: &'static str) -> Option<wgpu::ComputePassTimestampWrites<'_>> {
use core::sync::atomic::Ordering;
let mut at = self.next.load(Ordering::SeqCst);
loop {
if at + 2 > MAX_PASSES * 2 {
return None;
}
match self
.next
.compare_exchange(at, at + 2, Ordering::SeqCst, Ordering::SeqCst)
{
Ok(_) => break,
Err(seen) => at = seen,
}
}
self.labels.lock().expect("timestamp labels").push(label);
Some(wgpu::ComputePassTimestampWrites {
query_set: &self.set,
beginning_of_pass_write_index: Some(at),
end_of_pass_write_index: Some(at + 1),
})
}
pub fn resolve(&self, device: &wgpu::Device, queue: &wgpu::Queue) -> Result<Spans> {
let passes = self.next.load(core::sync::atomic::Ordering::SeqCst) / 2;
if passes == 0 {
return Ok(Spans {
spans: Vec::new(),
period_ns: f64::from(self.period_ns),
complete: true,
});
}
let used = passes * 2;
let bytes = u64::from(used) * 8;
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("isomesh timestamp resolve"),
});
encoder.resolve_query_set(&self.set, 0..used, &self.resolve, 0);
encoder.copy_buffer_to_buffer(&self.resolve, 0, &self.readback, 0, bytes);
queue.submit(Some(encoder.finish()));
let (sender, receiver) = std::sync::mpsc::channel();
self.readback
.slice(..bytes)
.map_async(wgpu::MapMode::Read, move |r| {
let _ = sender.send(r);
});
device
.poll(wgpu::PollType::Wait {
submission_index: None,
timeout: None,
})
.map_err(|_| Error::DeviceLost)?;
match receiver.recv() {
Ok(Ok(())) => {}
Ok(Err(_)) => return Err(Error::MapFailed),
Err(_) => return Err(Error::DeviceLost),
}
let ticks: Vec<u64> = {
let view = self
.readback
.slice(..bytes)
.get_mapped_range()
.map_err(|_| Error::MapFailed)?;
view.as_chunks::<8>()
.0
.iter()
.map(|c| u64::from_le_bytes(*c))
.collect()
};
self.readback.unmap();
let labels = self.labels.lock().expect("timestamp labels").clone();
let mut spans = Vec::with_capacity(passes as usize);
for (index, label) in labels.iter().enumerate() {
let (begin, end) = (ticks[index * 2], ticks[index * 2 + 1]);
if end < begin {
return Err(Error::TimestampsUnsupported);
}
spans.push(Span {
label,
ms: (end - begin) as f64 * f64::from(self.period_ns) / 1.0e6,
});
}
let complete = passes <= MAX_PASSES;
self.next.store(0, core::sync::atomic::Ordering::SeqCst);
self.labels.lock().expect("timestamp labels").clear();
Ok(Spans {
spans,
period_ns: f64::from(self.period_ns),
complete,
})
}
}