pub struct GpuTimer {
set: wgpu::QuerySet,
resolved: wgpu::Buffer,
staging: wgpu::Buffer,
period: f32,
mapping: std::sync::Arc<std::sync::atomic::AtomicU8>,
ticks: Vec<u64>,
marks: u32,
last_ms: f32,
}
const IDLE: u8 = 0;
const IN_FLIGHT: u8 = 1;
const READY: u8 = 2;
impl GpuTimer {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Option<Self> {
Self::with_marks(device, queue, 2)
}
pub fn with_marks(device: &wgpu::Device, queue: &wgpu::Queue, marks: u32) -> Option<Self> {
if !device.features().contains(wgpu::Features::TIMESTAMP_QUERY) {
return None;
}
let marks = marks.max(2);
let bytes = (marks as u64) * 8;
let set = device.create_query_set(&wgpu::QuerySetDescriptor {
label: Some("threers frame timer"),
ty: wgpu::QueryType::Timestamp,
count: marks,
});
Some(Self {
set,
resolved: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("threers frame timer resolve"),
size: bytes,
usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
}),
staging: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("threers frame timer readback"),
size: bytes,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
}),
period: queue.get_timestamp_period(),
mapping: std::sync::Arc::new(std::sync::atomic::AtomicU8::new(IDLE)),
ticks: vec![0; marks as usize],
marks,
last_ms: 0.0,
})
}
pub fn mark(&self, i: u32) -> wgpu::RenderPassTimestampWrites<'_> {
wgpu::RenderPassTimestampWrites {
query_set: &self.set,
beginning_of_pass_write_index: Some(i.min(self.marks - 1)),
end_of_pass_write_index: None,
}
}
pub fn mark_end(&self, i: u32) -> wgpu::RenderPassTimestampWrites<'_> {
wgpu::RenderPassTimestampWrites {
query_set: &self.set,
beginning_of_pass_write_index: None,
end_of_pass_write_index: Some(i.min(self.marks - 1)),
}
}
pub fn mark_both(&self, begin: u32, end: u32) -> wgpu::RenderPassTimestampWrites<'_> {
wgpu::RenderPassTimestampWrites {
query_set: &self.set,
beginning_of_pass_write_index: Some(begin.min(self.marks - 1)),
end_of_pass_write_index: Some(end.min(self.marks - 1)),
}
}
pub fn span_ms(&self, i: usize) -> f32 {
match (self.ticks.get(i), self.ticks.get(i + 1)) {
(Some(&a), Some(&b)) if b > a => (b - a) as f32 * self.period / 1.0e6,
_ => 0.0,
}
}
pub fn marks(&self) -> u32 {
self.marks
}
pub fn writes(&self) -> wgpu::RenderPassTimestampWrites<'_> {
wgpu::RenderPassTimestampWrites {
query_set: &self.set,
beginning_of_pass_write_index: Some(0),
end_of_pass_write_index: Some(1),
}
}
pub fn resolve(&self, encoder: &mut wgpu::CommandEncoder) {
use std::sync::atomic::Ordering;
if self.mapping.load(Ordering::Acquire) != IDLE {
return;
}
let bytes = (self.marks as u64) * 8;
encoder.resolve_query_set(&self.set, 0..self.marks, &self.resolved, 0);
encoder.copy_buffer_to_buffer(&self.resolved, 0, &self.staging, 0, bytes);
}
pub fn poll(&mut self, device: &wgpu::Device) {
use std::sync::atomic::Ordering;
match self.mapping.load(Ordering::Acquire) {
IDLE => {
let flag = self.mapping.clone();
flag.store(IN_FLIGHT, Ordering::Release);
self.staging
.slice(..)
.map_async(wgpu::MapMode::Read, move |r| {
flag.store(if r.is_ok() { READY } else { IDLE }, Ordering::Release);
});
let _ = device.poll(wgpu::PollType::Poll);
}
READY => {
if let Ok(view) = self.staging.slice(..).get_mapped_range() {
for (i, slot) in self.ticks.iter_mut().enumerate() {
*slot = u64::from_le_bytes(
view[i * 8..i * 8 + 8].try_into().unwrap_or([0; 8]),
);
}
if self.ticks[self.marks as usize - 1] > self.ticks[0] {
self.last_ms = (self.ticks[self.marks as usize - 1] - self.ticks[0]) as f32
* self.period
/ 1.0e6;
}
}
self.staging.unmap();
self.mapping.store(IDLE, Ordering::Release);
}
_ => {
let _ = device.poll(wgpu::PollType::Poll);
}
}
}
pub fn last_ms(&self) -> f32 {
self.last_ms
}
}