use std::time::{Duration, Instant};
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct RenderStats {
pub quads: usize,
pub shadows: usize,
pub images: usize,
pub image_uploads: usize,
pub gpu_image_cache_bytes: u64,
pub cpu_image_cache_bytes: u64,
pub image_resource_entries: usize,
pub image_resources_loading: usize,
pub image_resources_failed: usize,
pub animated_images: usize,
pub active_animations: usize,
pub svgs: usize,
pub svg_rasterizations: usize,
pub gpu_svg_cache_bytes: u64,
pub paths: usize,
pub path_vertices: usize,
pub skipped_paths: usize,
pub custom_shader_instances: usize,
pub custom_shader_compilations: usize,
pub cached_custom_shader_pipelines: usize,
pub skipped_custom_shader_instances: usize,
pub text_areas: usize,
pub draw_calls: usize,
pub reshaped_text_areas: usize,
pub retained_text_areas: usize,
pub retained_text_layouts: usize,
pub retained_text_renderers: usize,
pub cached_text_areas: usize,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct FrameMetrics {
pub frame_number: u64,
pub cpu_time: Duration,
pub smoothed_cpu_time: Duration,
pub frame_time: Duration,
pub smoothed_frame_time: Duration,
pub render: RenderStats,
}
impl FrameMetrics {
pub fn cpu_milliseconds(self) -> f64 {
self.cpu_time.as_secs_f64() * 1_000.0
}
pub fn smoothed_cpu_milliseconds(self) -> f64 {
self.smoothed_cpu_time.as_secs_f64() * 1_000.0
}
pub fn frame_milliseconds(self) -> f64 {
self.frame_time.as_secs_f64() * 1_000.0
}
pub fn smoothed_frame_milliseconds(self) -> f64 {
self.smoothed_frame_time.as_secs_f64() * 1_000.0
}
}
#[derive(Debug, Default)]
pub(crate) struct MetricsTracker {
metrics: FrameMetrics,
}
impl MetricsTracker {
pub fn current(&self) -> FrameMetrics {
self.metrics
}
pub fn record(&mut self, elapsed: FrameElapsed, render: RenderStats) {
let (smoothed_cpu_time, smoothed_frame_time) = if self.metrics.frame_number == 0 {
(elapsed.cpu_time, elapsed.frame_time)
} else {
(
self.metrics.smoothed_cpu_time.mul_f64(0.9) + elapsed.cpu_time.mul_f64(0.1),
self.metrics.smoothed_frame_time.mul_f64(0.9) + elapsed.frame_time.mul_f64(0.1),
)
};
self.metrics = FrameMetrics {
frame_number: self.metrics.frame_number + 1,
cpu_time: elapsed.cpu_time,
smoothed_cpu_time,
frame_time: elapsed.frame_time,
smoothed_frame_time,
render,
};
}
}
pub(crate) struct FrameTimer {
wall_time: Instant,
thread_cpu_time: Option<Duration>,
}
pub(crate) struct FrameElapsed {
cpu_time: Duration,
frame_time: Duration,
}
impl FrameTimer {
pub(crate) fn start() -> Self {
Self {
wall_time: Instant::now(),
thread_cpu_time: thread_cpu_time(),
}
}
pub(crate) fn elapsed(self) -> FrameElapsed {
let frame_time = self.wall_time.elapsed();
let cpu_time = self
.thread_cpu_time
.zip(thread_cpu_time())
.and_then(|(started, finished)| finished.checked_sub(started))
.unwrap_or(frame_time);
FrameElapsed {
cpu_time,
frame_time,
}
}
}
#[cfg(unix)]
fn thread_cpu_time() -> Option<Duration> {
let mut timestamp = std::mem::MaybeUninit::<libc::timespec>::uninit();
if unsafe { libc::clock_gettime(libc::CLOCK_THREAD_CPUTIME_ID, timestamp.as_mut_ptr()) } != 0 {
return None;
}
let timestamp = unsafe { timestamp.assume_init() };
let seconds = u64::try_from(timestamp.tv_sec).ok()?;
let nanoseconds = u32::try_from(timestamp.tv_nsec).ok()?;
(nanoseconds < 1_000_000_000).then(|| Duration::new(seconds, nanoseconds))
}
#[cfg(not(unix))]
fn thread_cpu_time() -> Option<Duration> {
None
}