use crate::Renderer;
pub struct GpuTimer {
set: wgpu::QuerySet,
resolved: wgpu::Buffer,
readback: wgpu::Buffer,
capacity: u32,
used: u32,
period_ns: f32,
}
impl GpuTimer {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, frames: u32) -> Option<Self> {
if !device.features().contains(wgpu::Features::TIMESTAMP_QUERY) {
return None;
}
let capacity = frames.max(1);
let bytes = u64::from(capacity) * 2 * 8;
Some(Self {
set: device.create_query_set(&wgpu::QuerySetDescriptor {
label: Some("frame timestamps"),
ty: wgpu::QueryType::Timestamp,
count: capacity * 2,
}),
resolved: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("frame timestamps resolved"),
size: bytes,
usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
}),
readback: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("frame timestamps readback"),
size: bytes,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
}),
capacity,
used: 0,
period_ns: queue.get_timestamp_period(),
})
}
pub fn next(&mut self, renderer: &mut Renderer) {
if self.used < self.capacity {
renderer.set_timestamp_writes(Some((self.set.clone(), self.used * 2)));
self.used += 1;
} else {
renderer.set_timestamp_writes(None);
}
}
pub fn resolve(&mut self, renderer: &mut Renderer, encoder: &mut wgpu::CommandEncoder) {
renderer.set_timestamp_writes(None);
if self.used == 0 {
return;
}
encoder.resolve_query_set(&self.set, 0..self.used * 2, &self.resolved, 0);
encoder.copy_buffer_to_buffer(
&self.resolved,
0,
&self.readback,
0,
u64::from(self.used) * 16,
);
}
pub fn readback(&self) -> &wgpu::Buffer {
&self.readback
}
pub fn take_ms(&mut self) -> (f64, u32) {
let n = self.used;
self.used = 0;
if n == 0 {
return (0.0, 0);
}
let ticks: u64 = {
let view = self
.readback
.get_mapped_range(..u64::from(n) * 16)
.expect("mapped");
view.as_chunks::<16>()
.0
.iter()
.map(|pair| {
let (begin, end) = pair.split_at(8);
let tick = |b: &[u8]| u64::from_le_bytes(b.try_into().expect("8 bytes"));
tick(end).saturating_sub(tick(begin))
})
.sum()
};
self.readback.unmap();
(ticks as f64 * f64::from(self.period_ns) / 1e6, n)
}
}