use std::{sync::Arc, time::Duration};
use super::{ApplicationScopeReport, FrameProfile};
use crate::app::PassReasons;
pub const MAX_ACTIVE_SESSIONS: usize = 8;
pub const MAX_SAMPLES_PER_SESSION: usize = 240;
pub const MAX_TRACKED_WINDOWS: usize = 64;
pub const MAX_WINDOW_ID_BYTES: usize = 256;
pub const MAX_ENDED_SESSION_IDS: usize = 64;
pub const MAX_SPANS_PER_PASS: usize = 1024;
pub const MAX_COMPONENT_SPANS_PER_PASS: usize = 8192;
pub const MAX_PENDING_INPUTS: usize = 256;
pub const DEFAULT_RECORDING_MAX_BYTES: u64 = 1 << 30;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct SessionId(pub u64);
#[derive(Clone, Copy, Debug)]
pub struct SessionOptions {
pub max_samples: usize,
pub include_devtools: bool,
}
impl Default for SessionOptions {
fn default() -> Self {
Self {
max_samples: 120,
include_devtools: false,
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct RecordingOptions {
pub max_bytes: u64,
pub include_devtools: bool,
pub detailed: bool,
pub screenshots: Option<ScreenshotOptions>,
}
impl Default for RecordingOptions {
fn default() -> Self {
Self {
max_bytes: DEFAULT_RECORDING_MAX_BYTES,
include_devtools: false,
detailed: false,
screenshots: None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ScreenshotOptions {
pub max_per_second: u32,
pub max_width: u32,
pub max_height: u32,
}
impl Default for ScreenshotOptions {
fn default() -> Self {
Self {
max_per_second: 4,
max_width: 320,
max_height: 200,
}
}
}
impl ScreenshotOptions {
pub fn min_interval(&self) -> Duration {
Duration::from_secs(1) / self.max_per_second.max(1)
}
}
#[derive(Clone)]
pub struct FrameScreenshot {
pub window: String,
pub frame_id: u64,
pub captured_ms: f64,
pub width: u32,
pub height: u32,
pub rgba: Vec<u8>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RecordingStatus {
pub max_bytes: u64,
pub size_bytes: u64,
pub stopped_at_limit: bool,
pub stopped_ms: Option<f64>,
pub detailed: bool,
pub screenshots: u64,
pub screenshot_bytes: u64,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SessionStatus {
pub id: SessionId,
pub started_ms: f64,
pub observed_ms: f64,
pub completed_samples: u64,
pub recording: Option<RecordingStatus>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProfileError {
FeatureDisabled,
SessionLimit,
InvalidSampleLimit,
InvalidByteLimit,
UnknownSession,
AlreadyEnded,
Closed,
}
impl std::fmt::Display for ProfileError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if *self == Self::InvalidSampleLimit {
return write!(f, "max_samples must be between 1 and {MAX_SAMPLES_PER_SESSION}");
}
f.write_str(match self {
Self::FeatureDisabled => "profiling requires the perf_profile Cargo feature",
Self::SessionLimit => "the concurrent profiling session limit is reached",
Self::InvalidSampleLimit => unreachable!("handled above"),
Self::InvalidByteLimit => "max_bytes must be above zero",
Self::UnknownSession => "unknown profiling session id",
Self::AlreadyEnded => "profiling session already ended",
Self::Closed => "profiling producer has closed",
})
}
}
impl std::error::Error for ProfileError {}
#[derive(Clone, Copy, Debug)]
pub struct BuildAvailability {
pub perf_profile: bool,
pub debug_assertions: bool,
pub canvas: bool,
pub wgpu: bool,
pub dx12: bool,
pub devtools: bool,
pub gpu_timestamps: GpuTimestampAvailability,
}
impl Default for BuildAvailability {
fn default() -> Self {
Self {
perf_profile: cfg!(feature = "perf_profile"),
debug_assertions: cfg!(debug_assertions),
canvas: cfg!(feature = "canvas"),
wgpu: cfg!(feature = "wgpu"),
dx12: cfg!(all(feature = "dx12", target_os = "windows")),
devtools: cfg!(feature = "devtools"),
gpu_timestamps: GpuTimestampAvailability::default(),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct GpuTimestampAvailability {
pub available: bool,
pub reason: Option<&'static str>,
pub adapter_backend: Option<&'static str>,
}
impl GpuTimestampAvailability {
#[cfg_attr(not(all(feature = "wgpu", feature = "perf_profile")), allow(dead_code))]
pub(crate) const NO_TIMESTAMP_QUERY: &'static str = "the wgpu adapter does not offer timestamp queries";
#[cfg_attr(
not(all(feature = "dx12", target_os = "windows", feature = "perf_profile")),
allow(dead_code)
)]
pub(crate) const NATIVE_DX12: &'static str = "the native DX12 renderer does not measure GPU time";
const NO_PERF_PROFILE: &'static str = "GPU timestamp queries require the perf_profile Cargo feature";
const NO_WGPU: &'static str = "only the wgpu renderer measures GPU time";
const NOT_RENDERED: &'static str = "no window has rendered with wgpu yet";
#[cfg_attr(not(any(feature = "serde", feature = "mcp", feature = "devtools")), allow(dead_code))]
pub(crate) const REASONS: [&'static str; 5] = [
Self::NO_TIMESTAMP_QUERY,
Self::NATIVE_DX12,
Self::NO_PERF_PROFILE,
Self::NO_WGPU,
Self::NOT_RENDERED,
];
pub(crate) fn unavailable(reason: &'static str) -> Self {
Self {
available: false,
reason: Some(reason),
adapter_backend: None,
}
}
}
impl Default for GpuTimestampAvailability {
fn default() -> Self {
Self::unavailable(if !cfg!(feature = "perf_profile") {
Self::NO_PERF_PROFILE
} else if !cfg!(feature = "wgpu") {
Self::NO_WGPU
} else {
Self::NOT_RENDERED
})
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct GpuTiming {
pub ui: Duration,
pub canvas: Option<Duration>,
}
impl GpuTiming {
pub fn total(&self) -> Duration {
self.ui + self.canvas.unwrap_or_default()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Phase {
PassSetup,
PassNotifications,
LayoutUpdate,
LayoutCompute,
ComponentAfterLayout,
Rebuild,
Commit,
QuadResolve,
GlyphRasterize,
CanvasRecording,
CanvasPreparation,
Render,
CanvasBackend,
CanvasTessellation,
CanvasAssetUpload,
CanvasBufferUpload,
CanvasSubmission,
CanvasCommands,
RenderInit,
RenderAcquire,
RenderEncode,
RenderSubmit,
RenderPresent,
InputDispatch,
}
impl Phase {
pub fn name(self) -> &'static str {
match self {
Self::PassSetup => "pass_setup",
Self::PassNotifications => "pass_notifications",
Self::LayoutUpdate => "layout_update",
Self::LayoutCompute => "layout_compute",
Self::ComponentAfterLayout => "component_after_layout",
Self::Rebuild => "ui_rebuild",
Self::Commit => "ui_commit",
Self::QuadResolve => "quad_resolve",
Self::GlyphRasterize => "glyph_rasterize",
Self::CanvasRecording => "canvas_recording",
Self::CanvasPreparation => "canvas_preparation",
Self::Render => "render",
Self::CanvasBackend => "canvas_backend",
Self::CanvasTessellation => "canvas_tessellation",
Self::CanvasAssetUpload => "canvas_asset_upload",
Self::CanvasBufferUpload => "canvas_buffer_upload",
Self::CanvasSubmission => "canvas_submission",
Self::CanvasCommands => "canvas_commands",
Self::RenderInit => "render_init",
Self::RenderAcquire => "render_acquire",
Self::RenderEncode => "render_encode",
Self::RenderSubmit => "render_submit",
Self::RenderPresent => "render_present",
Self::InputDispatch => "input_dispatch",
}
}
}
#[derive(Clone, Debug)]
pub struct WindowStatus {
pub id: String,
pub open: bool,
pub devtools: bool,
pub gpu_timestamps: Option<GpuTimestampAvailability>,
}
#[derive(Clone, Debug)]
pub struct InFlightObservation {
pub window: String,
pub frame_id: Option<u64>,
pub phase: Phase,
pub started_ms: f64,
pub elapsed_ms: f64,
pub phase_elapsed_ms: f64,
pub started_before_session: bool,
}
#[derive(Clone)]
pub struct ProfileSample {
pub sequence: u64,
pub window: String,
pub started_ms: f64,
pub completed_ms: f64,
pub data: SampleData,
}
#[derive(Clone)]
#[allow(clippy::large_enum_variant)]
pub enum SampleData {
Pass(PassSample),
UiUpdate(UiUpdateSample),
InputDispatch(InputDispatchSample),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum InputKind {
Pointer,
Keyboard,
Scroll,
}
impl InputKind {
pub fn name(self) -> &'static str {
match self {
Self::Pointer => "pointer",
Self::Keyboard => "keyboard",
Self::Scroll => "scroll",
}
}
}
#[derive(Clone)]
pub struct InputDispatchSample {
pub frame_id: Option<u64>,
pub kind: InputKind,
pub total: Duration,
pub interaction_id: u64,
pub queue_delay: Duration,
pub presented_frame_id: Option<u64>,
pub input_to_present: Option<Duration>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PresentTiming {
pub presented_ms: f64,
pub interval: Option<Duration>,
pub refresh_interval: Option<Duration>,
pub continuous: bool,
pub missed_vsyncs: u32,
}
impl PresentTiming {
pub fn missed_vsync(&self) -> bool {
self.missed_vsyncs > 0
}
}
#[derive(Clone, Copy, Debug, Default)]
pub(crate) struct PresentTracker {
last: Option<crate::time::Instant>,
}
impl PresentTracker {
pub(crate) fn present(
&mut self,
presented: crate::time::Instant,
wanted: Option<crate::time::Instant>,
refresh: Option<Duration>,
) -> (Option<Duration>, bool, u32) {
let previous = self.last.replace(presented);
let interval = previous.map(|previous| presented.saturating_duration_since(previous));
let (Some(previous), Some(wanted), Some(refresh)) = (previous, wanted, refresh) else {
return (interval, false, 0);
};
if refresh.is_zero() || wanted > previous + refresh {
return (interval, false, 0);
}
let late = presented.saturating_duration_since(wanted.max(previous));
let refreshes = (late.as_secs_f64() / refresh.as_secs_f64()).round();
(interval, true, (refreshes as u32).saturating_sub(1))
}
}
#[derive(Clone)]
pub struct PassSample {
pub frame_id: Option<u64>,
pub rendered: bool,
pub cached_render_list: bool,
pub total: Duration,
pub layout_update: Duration,
pub layout_compute: Duration,
pub component_after_layout: Duration,
pub layout_recalculated: bool,
pub canvas_recording: Duration,
pub canvas_preparation: Duration,
pub canvas_text: Option<CanvasTextProfile>,
pub backend: &'static str,
pub frame: Option<FrameProfile>,
pub spans: Vec<PhaseSpan>,
pub dropped_spans: u32,
pub reasons: PassReasons,
pub present: Option<PresentTiming>,
pub counters: Option<PassCounters>,
pub screenshot: bool,
pub gpu: Option<GpuTiming>,
pub component_layouts: Vec<ComponentLayouts>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PhaseSpan {
pub phase: Phase,
pub depth: u8,
pub start_ns: u64,
pub end_ns: u64,
pub component: Option<&'static str>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ComponentLayouts {
pub component: Option<&'static str>,
pub reason: &'static str,
pub nodes: u32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum RenderTrigger {
Signal,
Memo,
Store,
Context,
Form,
Props,
SlotChildren,
Mount,
ListItem,
Unknown,
}
impl RenderTrigger {
pub fn name(self) -> &'static str {
match self {
Self::Signal => "signal",
Self::Memo => "memo",
Self::Store => "store",
Self::Context => "context",
Self::Form => "form",
Self::Props => "props",
Self::SlotChildren => "slot_children",
Self::Mount => "mount",
Self::ListItem => "list_item",
Self::Unknown => "unknown",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct RenderSource {
pub trigger: RenderTrigger,
pub value_type: Option<&'static str>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct RenderCause {
pub component: &'static str,
pub source: RenderSource,
pub via: Option<RenderSource>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PassCounters {
pub nodes: usize,
pub memory_bytes: usize,
pub caches: CacheSizes,
pub allocations: Option<PassAllocations>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct CacheSizes {
pub glyph_atlas_bytes: usize,
pub text_cache_bytes: usize,
pub canvas_text_cache_bytes: usize,
pub canvas_asset_cache_bytes: usize,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PassAllocations {
pub allocations: u64,
pub frees: u64,
pub allocated_bytes: u64,
pub freed_bytes: u64,
pub live_bytes: u64,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct CanvasTextProfile {
pub measure_calls: u64,
pub fill_calls: u64,
pub shape_calls: u64,
pub shape_cache_hits: u64,
pub shape_cache_misses: u64,
pub shape_cache_evictions: u64,
pub shape_cache_uncached: u64,
pub shape_cache_stretch_bytes: u64,
pub produced_bitmap_bytes: u64,
pub total: Duration,
pub buffer_font_shape: Duration,
pub glyph_prepare: Duration,
pub bitmap_composition: Duration,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UiUpdateKind {
RootRebuild,
SubtreeRefresh,
}
#[derive(Clone)]
pub struct UiUpdateSample {
pub frame_id: Option<u64>,
pub kind: UiUpdateKind,
pub total: Duration,
pub commit: Duration,
pub causes: Vec<RenderCause>,
}
#[derive(Clone)]
pub struct ProfileReport {
pub id: SessionId,
pub finalized: bool,
pub started_ms: f64,
pub ended_ms: Option<f64>,
pub observed_ms: f64,
pub build: BuildAvailability,
pub max_samples: usize,
pub completed_samples: u64,
pub dropped_samples: u64,
pub boundary_excluded_samples: u64,
pub untracked_windows: u64,
pub windows: Vec<WindowStatus>,
pub in_flight: Vec<InFlightObservation>,
pub samples: Vec<Arc<ProfileSample>>,
pub application_scopes: Option<ApplicationScopeReport>,
pub recording: Option<RecordingStatus>,
pub screenshots: Vec<Arc<FrameScreenshot>>,
}
#[derive(Clone, Debug)]
pub struct SessionStarted {
pub id: SessionId,
pub started_ms: f64,
pub max_samples: usize,
pub build: BuildAvailability,
pub recording_max_bytes: Option<u64>,
}