use sim_engine::{
GpuTimingBatch, GpuTimingId, GpuTimingSample, GpuTimingSource, GpuTimingStatistics,
WgpuRenderer,
};
const MAX_PENDING: usize = 16;
const MAX_COLLECTED: usize = 8;
#[derive(Debug, Clone, Copy)]
pub struct DesktopGpuTimingSample {
logic_frame: u64,
generation: u64,
sample: GpuTimingSample,
}
impl DesktopGpuTimingSample {
pub const fn logic_frame_index(self) -> u64 {
self.logic_frame
}
pub const fn device_generation(self) -> u64 {
self.generation
}
pub const fn sample(self) -> GpuTimingSample {
self.sample
}
}
#[derive(Debug, Default)]
pub struct DesktopGpuTimings {
generation: u64,
statistics: Option<GpuTimingStatistics>,
last_batch: Option<GpuTimingBatch>,
samples: [Option<DesktopGpuTimingSample>; MAX_COLLECTED],
pending: PendingTimings<GpuTimingId>,
unmatched_samples: u64,
evicted_correlations: u64,
}
impl DesktopGpuTimings {
pub const fn device_generation(&self) -> u64 {
self.generation
}
pub const fn statistics(&self) -> Option<GpuTimingStatistics> {
self.statistics
}
pub const fn last_batch(&self) -> Option<GpuTimingBatch> {
self.last_batch
}
pub fn samples(&self) -> impl Iterator<Item = &DesktopGpuTimingSample> {
self.samples.iter().filter_map(Option::as_ref)
}
pub const fn unmatched_samples(&self) -> u64 {
self.unmatched_samples
}
pub const fn evicted_correlations(&self) -> u64 {
self.evicted_correlations
}
pub(super) fn reset(&mut self, generation: u64, statistics: GpuTimingStatistics) {
self.reset_generation(generation);
self.statistics = Some(statistics);
}
fn reset_generation(&mut self, generation: u64) {
*self = Self {
generation,
..Self::default()
};
}
pub(super) fn submitted(
&mut self,
logic_frame: u64,
source: GpuTimingSource,
id: Option<GpuTimingId>,
) {
if let Some(id) = id
&& self.pending.insert(id, source, logic_frame)
{
self.evicted_correlations = self.evicted_correlations.saturating_add(1);
}
}
pub(super) fn collect(&mut self, renderer: &mut WgpuRenderer) {
let batch = renderer.collect_gpu_timings();
self.statistics = Some(renderer.gpu_timing_statistics());
if batch.samples().is_empty() {
return;
}
self.samples.fill(None);
for (index, sample) in batch.samples().iter().copied().enumerate() {
if let Some(logic_frame) = self.pending.take(sample.id(), sample.source())
&& let Some(destination) = self.samples.get_mut(index)
{
*destination = Some(DesktopGpuTimingSample {
logic_frame,
generation: self.generation,
sample,
});
} else {
self.unmatched_samples = self.unmatched_samples.saturating_add(1);
}
}
self.last_batch = Some(batch);
}
}
#[derive(Debug, Clone, Copy)]
struct PendingTiming<Id> {
id: Id,
source: GpuTimingSource,
logic_frame: u64,
}
#[derive(Debug)]
struct PendingTimings<Id> {
entries: [Option<PendingTiming<Id>>; MAX_PENDING],
}
impl<Id: Copy> Default for PendingTimings<Id> {
fn default() -> Self {
Self {
entries: [None; MAX_PENDING],
}
}
}
impl<Id: Copy + Ord> PendingTimings<Id> {
fn insert(&mut self, id: Id, source: GpuTimingSource, logic_frame: u64) -> bool {
if self
.entries
.iter()
.flatten()
.any(|entry| entry.id == id && entry.source == source)
{
return false;
}
let vacant = self.entries.iter().position(Option::is_none);
let index = vacant.or_else(|| {
self.entries
.iter()
.enumerate()
.filter_map(|(index, entry)| entry.map(|entry| (index, entry.id)))
.min_by_key(|(_, id)| *id)
.map(|(index, _)| index)
});
let Some(index) = index else {
return false;
};
self.entries[index] = Some(PendingTiming {
id,
source,
logic_frame,
});
vacant.is_none()
}
fn take(&mut self, id: Id, source: GpuTimingSource) -> Option<u64> {
self.entries
.iter_mut()
.find(|entry| entry.is_some_and(|entry| entry.id == id && entry.source == source))?
.take()
.map(|entry| entry.logic_frame)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn correlation_requires_both_id_and_source_and_accepts_out_of_order_completion() {
let mut pending = PendingTimings::<u64>::default();
assert!(!pending.insert(10, GpuTimingSource::Scene3d, 100));
assert!(!pending.insert(11, GpuTimingSource::FrameComposer, 100));
assert!(!pending.insert(12, GpuTimingSource::Scene3d, 101));
assert_eq!(pending.take(10, GpuTimingSource::FrameComposer), None);
assert_eq!(pending.take(12, GpuTimingSource::Scene3d), Some(101));
assert_eq!(pending.take(10, GpuTimingSource::Scene3d), Some(100));
assert_eq!(pending.take(11, GpuTimingSource::FrameComposer), Some(100));
assert_eq!(pending.take(10, GpuTimingSource::Scene3d), None);
}
#[test]
fn lost_samples_have_bounded_metadata_and_cannot_reuse_an_evicted_frame() {
let mut pending = PendingTimings::<u64>::default();
for id in 1..=MAX_PENDING as u64 {
assert!(!pending.insert(id, GpuTimingSource::Scene3d, id + 100));
}
assert!(pending.insert(17, GpuTimingSource::Scene3d, 117));
assert_eq!(pending.take(1, GpuTimingSource::Scene3d), None);
assert_eq!(pending.take(17, GpuTimingSource::Scene3d), Some(117));
assert!(!pending.insert(18, GpuTimingSource::Scene3d, 118));
assert_eq!(pending.take(2, GpuTimingSource::Scene3d), Some(102));
}
#[test]
fn repeated_submission_does_not_reassign_a_timing_id_to_another_frame() {
let mut pending = PendingTimings::<u64>::default();
assert!(!pending.insert(1, GpuTimingSource::Scene3d, 10));
assert!(!pending.insert(1, GpuTimingSource::Scene3d, 11));
assert_eq!(pending.take(1, GpuTimingSource::Scene3d), Some(10));
}
#[test]
fn uninitialized_diagnostics_have_no_fabricated_gpu_times() {
let diagnostics = DesktopGpuTimings::default();
assert!(diagnostics.statistics().is_none());
assert!(diagnostics.last_batch().is_none());
assert_eq!(diagnostics.samples().count(), 0);
assert_eq!(diagnostics.unmatched_samples(), 0);
assert_eq!(diagnostics.evicted_correlations(), 0);
}
#[test]
fn recovery_generation_discards_old_diagnostic_counters() {
let mut diagnostics = DesktopGpuTimings {
generation: 1,
unmatched_samples: 7,
evicted_correlations: 9,
..DesktopGpuTimings::default()
};
diagnostics.reset_generation(2);
assert_eq!(diagnostics.device_generation(), 2);
assert_eq!(diagnostics.unmatched_samples(), 0);
assert_eq!(diagnostics.evicted_correlations(), 0);
assert!(diagnostics.last_batch().is_none());
assert!(diagnostics.statistics().is_none());
assert_eq!(diagnostics.samples().count(), 0);
}
}