From 4f6d97b9de7d9f167da8b7832eeecea22c5a9efa Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Fri, 9 Oct 2026 05:44:50 +0000 Subject: [PATCH] gpui: Measure frame pacing against each window's refresh rate (#65351) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Frame and hang telemetry judged every frame against a fixed 24 ms budget. That's too lax on 120–360 Hz displays and too strict at 30 Hz, so the numbers couldn't be compared across users or catch regressions on fast displays. This judges each frame against its window's display refresh interval (from #65059), as measurement version 3. **Frame timing.** A frame's work runs from the later of its frame signal and its first invalidation until its submission to the platform begins, on every platform, so time spent waiting for a late frame signal or inside the submission doesn't count. A frame is late when its work exceeds one refresh interval, but never less than 8.33 ms (one refresh at 120 Hz), since frames rarely fit a single refresh on faster displays yet; on displays whose refresh interval is unknown (X11, web) the budget is 16.7 ms. Missed refreshes still count against the real interval. **Frame Duration Report**, per window and refresh interval: on-time, late, and unmeasured frame counts and missed refreshes, overall and for frames that responded to input; work (as a percentage of the refresh interval) and draw-time buckets, computed from hdrhistogram histograms; GPU and CPU. **Hang Incidents.** Threshold incidents (one event of 100 ms or more) are unchanged. Budget incidents are split by trigger: - `late_frame`: a presented frame over its budget, listing the events that overlap that frame's work; - `blocking_work`: in an interval with no measured frame, a single event of at least the frame budget (16.7 ms in release builds), long enough to delay a frame. Total foreground time across an interval no longer counts, since gaps between short work don't block frames. Draw contributors carry request-layout, prepaint, and paint times, and any entity view phase whose own work (excluding nested views) takes 0.5 ms or more becomes a contributor named by its view type. Events also report counts per trigger, incidents during active use (within a minute of a key press, click, or scroll) with active seconds for rates per active hour, stall buckets, and contributor totals summed across every incident (`view::`, `action:…`, `task:…`). **Verification.** With a synthetic render delay on a 240 Hz display, on-time frames went from 99.9% at no delay to 0% at 6 ms. In a real Zed on Linux at 360 Hz, scrolling a markdown preview with #63138's per-frame code-block highlighting reintroduced roughly doubled missed refreshes per frame (3.2 to 6.0) and attributed the extra time to `MarkdownPreviewView`'s request-layout phase. Profiler overhead was +2.3% of main-thread time in a 1,500-view GPUI stress test and about 0.3% in the Zed scroll run. Not yet verified: Windows, and input-driven frames from real use. Time spent inside the platform submission (GPU, compositor) isn't measured on any platform. Release Notes: - [GPUI] Improved frame and hang telemetry to measure frames against each window's display refresh rate --- Cargo.lock | 4 +- crates/gpui/src/profiler.rs | 587 ++++++++++++++++- crates/gpui/src/profiler/hang.rs | 599 ++++++++++++++---- crates/gpui/src/profiler/hang/monitor.rs | 9 +- crates/gpui/src/profiler/journal.rs | 20 +- crates/gpui/src/view.rs | 62 +- crates/gpui/src/window.rs | 22 +- crates/hang_telemetry/Cargo.toml | 2 +- crates/hang_telemetry/src/hang_telemetry.rs | 480 +++++++++++--- crates/input_latency_ui/Cargo.toml | 2 + .../input_latency_ui/src/input_latency_ui.rs | 307 +++++---- 11 files changed, 1743 insertions(+), 351 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9f390074738..c6b0a9b1793 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7864,8 +7864,8 @@ name = "hang_telemetry" version = "0.1.0" dependencies = [ "gpui", - "hdrhistogram", "log", + "serde", "serde_json", "telemetry_events", ] @@ -8799,6 +8799,8 @@ dependencies = [ "collections", "gpui", "hdrhistogram", + "serde_json", + "sysinfo 0.39.6", "telemetry", ] diff --git a/crates/gpui/src/profiler.rs b/crates/gpui/src/profiler.rs index e8108c106b8..ea1cd5ae1df 100644 --- a/crates/gpui/src/profiler.rs +++ b/crates/gpui/src/profiler.rs @@ -797,10 +797,139 @@ pub struct FrameTiming { pub draw_start: Instant, /// When `Window::draw` finished. pub draw_end: Instant, + /// The refresh interval of the window's display when the frame was drawn, + /// or `None` when the platform doesn't report it. + pub refresh_interval: Option, + /// When the platform's frame signal for this frame fired, or `None` when + /// the platform doesn't report it. Coalesced signals report the first. + pub signal_at: Option, + /// How long each phase of the draw took. + pub phases: DrawPhases, +} + +/// How long each phase of a window draw took. +#[cfg(feature = "profiler")] +#[derive(Debug, Copy, Clone, Default, PartialEq, Eq)] +pub struct DrawPhases { + /// Rendering views into elements and requesting their layout. + pub request_layout: Duration, + /// Computing layout and prepainting elements, including deferred draws, + /// prompts, drags, and tooltips. + pub prepaint: Duration, + /// Painting elements into the scene. + pub paint: Duration, +} + +/// A phase of drawing a view. +#[cfg(feature = "profiler")] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum ViewPhase { + /// Rendering the view and requesting its layout. + RequestLayout, + /// Prepainting the view's elements. Views whose cached elements are + /// stale also render and lay out here. + Prepaint, + /// Painting the view's elements. + Paint, } +#[cfg(feature = "profiler")] +impl ViewPhase { + /// The phase's name, e.g. `"prepaint"`. + pub fn as_str(self) -> &'static str { + match self { + Self::RequestLayout => "request_layout", + Self::Prepaint => "prepaint", + Self::Paint => "paint", + } + } +} + +/// Views whose own work in one draw phase takes less than this aren't +/// recorded, keeping the journal's per-frame cost bounded while still naming +/// the views that make a frame late. +#[cfg(feature = "profiler")] +pub const VIEW_TIMING_FLOOR: Duration = Duration::from_micros(500); + +/// One phase of drawing one view, recorded when its own work took at least +/// [`VIEW_TIMING_FLOOR`]. +#[cfg(feature = "profiler")] +#[derive(Debug, Copy, Clone)] +pub struct ViewTiming { + /// The view's type name. + pub name: &'static str, + /// The draw phase. + pub phase: ViewPhase, + /// When the view's phase began. + pub start: Instant, + /// When the view's phase ended. + pub end: Instant, + /// The phase's duration excluding views nested inside it, so a parent + /// view isn't blamed for its children's work. + pub self_duration: Duration, +} + +/// The least work a frame can take before it counts as late: one refresh +/// at 120 Hz. Frames rarely fit a single refresh on faster displays yet, so +/// judging them by it would count nearly every frame as late and hide +/// regressions; missed refreshes still measure against the real interval. +#[cfg(feature = "profiler")] +pub const FRAME_BUDGET_FLOOR: Duration = Duration::from_nanos(8_333_333); + +/// The work a frame can take before it counts as late when its display's +/// refresh interval is unknown: one refresh at 60 Hz, the most common rate, +/// so frames on faster displays may be judged leniently but none too strictly. +#[cfg(feature = "profiler")] +pub const UNKNOWN_REFRESH_FRAME_BUDGET: Duration = Duration::from_nanos(16_666_667); + #[cfg(feature = "profiler")] impl FrameTiming { + /// When the frame's work began: the later of its signal and its first + /// invalidation, since waiting for the platform's frame signal isn't work, + /// however late it fires. `None` without a frame signal. + pub fn work_start(&self) -> Option { + let signal_at = self.signal_at?; + // A frame signal can fire while the main thread is busy and only be + // handled after the window became dirty; time before then isn't the + // frame's. + Some( + self.dirty_at + .map_or(signal_at, |dirty_at| dirty_at.max(signal_at)), + ) + } + + /// The main-thread time from [`FrameTiming::work_start`] until the frame + /// was submitted at `submitted_at`: the start of its submission, which may + /// consist mostly of waiting for the display to free a buffer. + pub fn work(&self, submitted_at: Instant) -> Option { + Some(submitted_at.saturating_duration_since(self.work_start()?)) + } + + /// Whether the frame's work, submitted at `submitted_at`, exceeded + /// [`FrameTiming::budget`], when its work is known. + pub fn is_late(&self, submitted_at: Instant) -> Option { + Some(self.work(submitted_at)? > self.budget()) + } + + /// The work a frame can take before it counts as late: one refresh + /// interval, but no less than [`FRAME_BUDGET_FLOOR`], or + /// [`UNKNOWN_REFRESH_FRAME_BUDGET`] when the interval is unknown. + pub fn budget(&self) -> Duration { + self.refresh_interval + .map_or(UNKNOWN_REFRESH_FRAME_BUDGET, |interval| { + interval.max(FRAME_BUDGET_FLOOR) + }) + } + + /// How many refreshes the frame missed when submitted at `submitted_at`: + /// zero when its work fit within one refresh interval. + pub fn missed_refreshes(&self, submitted_at: Instant) -> Option { + let refresh_interval = self.refresh_interval?; + let work = self.work(submitted_at)?; + let refreshes = work.as_nanos().div_ceil(refresh_interval.as_nanos()).max(1); + Some(u64::try_from(refreshes - 1).unwrap_or(u64::MAX)) + } + /// Time spent inside `Window::draw`. pub fn draw_duration(&self) -> Duration { self.draw_end.duration_since(self.draw_start) @@ -859,6 +988,173 @@ pub struct FrameDurationSnapshot { /// Histogram of intervals between consecutively presented frames while the /// window was animating, in nanoseconds. pub present_interval_histogram: Histogram, + /// The same frames, split by the refresh interval of the window's display + /// when they were drawn. + pub by_refresh_interval: Vec, +} + +/// Upper bounds, in milliseconds, of the duration buckets in +/// [`RefreshIntervalFrames`]. Each bucket counts values up to and including its +/// bound; a final bucket counts everything longer. +#[cfg(feature = "profiler")] +pub const FRAME_DURATION_BUCKETS_MS: [u64; 9] = [4, 8, 16, 33, 50, 100, 250, 500, 1000]; + +/// Upper bounds, in percent of the display's real refresh interval, of the +/// work-per-frame buckets in [`RefreshIntervalFrames`]. Each bucket counts +/// values up to and including its bound; a final bucket counts everything +/// more. Whether a frame was on time is judged by [`FrameTiming::budget`] +/// instead, which never drops below [`FRAME_BUDGET_FLOOR`], so on displays +/// faster than 120 Hz frames above 100% can still be on time. +#[cfg(feature = "profiler")] +pub const FRAME_WORK_BUCKETS_PERCENT: [u64; 7] = [25, 50, 75, 100, 150, 200, 400]; + +/// Counts `histogram`'s values above the previous bound and up to and +/// including each of `upper_bounds`, plus a final count of the values above +/// the last bound. +#[cfg(feature = "profiler")] +pub fn histogram_bucket_counts( + histogram: &Histogram, + upper_bounds: impl IntoIterator, +) -> Vec { + let mut counted = 0; + let mut counts: Vec = upper_bounds + .into_iter() + .map(|bound| { + // Cumulative counts, since adjacent bounds can share a histogram + // bucket. + let cumulative = histogram.count_between(0, bound); + let count = cumulative.saturating_sub(counted); + counted = counted.max(cumulative); + count + }) + .collect(); + counts.push(histogram.len().saturating_sub(counted)); + counts +} + +/// Statistics for the frames a window drew and presented while its display had +/// one refresh interval. +/// +/// A frame is on time when its [`FrameTiming::work`] fit within +/// [`FrameTiming::budget`]. +#[cfg(feature = "profiler")] +#[derive(Clone, Debug)] +pub struct RefreshIntervalFrames { + /// The display's refresh interval, or `None` when the platform doesn't + /// report it. Frame pacing is only measured for known intervals. + pub refresh_interval: Option, + /// Frames drawn, whether or not they were presented. + pub frames_drawn: u64, + /// Draw durations, in nanoseconds. + pub draw_duration: Histogram, + /// Presented frames whose work fit within [`FrameTiming::budget`]. + pub frames_on_time: u64, + /// Presented frames whose work exceeded [`FrameTiming::budget`]. + pub frames_late: u64, + /// Refreshes that on-time and late frames missed in total, when the + /// refresh interval is known. + pub missed_refreshes: u64, + /// Presented frames without a frame signal to measure their work from. + pub frames_unmeasured: u64, + /// Work of on-time and late frames, in nanoseconds. + pub work: Histogram, + /// Of `frames_on_time`, the frames that responded to input. + pub input_frames_on_time: u64, + /// Of `frames_late`, the frames that responded to input. + pub input_frames_late: u64, + /// Work of on-time and late frames that responded to input, in + /// nanoseconds. + pub input_work: Histogram, +} + +#[cfg(feature = "profiler")] +impl RefreshIntervalFrames { + fn new(refresh_interval: Option, empty_histogram: &Histogram) -> Self { + Self { + refresh_interval, + frames_drawn: 0, + draw_duration: empty_histogram.clone(), + frames_on_time: 0, + frames_late: 0, + missed_refreshes: 0, + frames_unmeasured: 0, + work: empty_histogram.clone(), + input_frames_on_time: 0, + input_frames_late: 0, + input_work: empty_histogram.clone(), + } + } + + /// The frames recorded since `earlier`, a previous snapshot of the same + /// statistics. + pub fn since(&self, earlier: &Self) -> Self { + let subtract = |current: &Histogram, earlier: &Histogram| { + let mut delta = current.clone(); + match delta.subtract(earlier) { + Ok(()) => delta, + Err(error) => { + log::error!("failed to subtract frame histograms: {error}"); + current.clone() + } + } + }; + Self { + refresh_interval: self.refresh_interval, + frames_drawn: self.frames_drawn.saturating_sub(earlier.frames_drawn), + draw_duration: subtract(&self.draw_duration, &earlier.draw_duration), + frames_on_time: self.frames_on_time.saturating_sub(earlier.frames_on_time), + frames_late: self.frames_late.saturating_sub(earlier.frames_late), + missed_refreshes: self + .missed_refreshes + .saturating_sub(earlier.missed_refreshes), + frames_unmeasured: self + .frames_unmeasured + .saturating_sub(earlier.frames_unmeasured), + work: subtract(&self.work, &earlier.work), + input_frames_on_time: self + .input_frames_on_time + .saturating_sub(earlier.input_frames_on_time), + input_frames_late: self + .input_frames_late + .saturating_sub(earlier.input_frames_late), + input_work: subtract(&self.input_work, &earlier.input_work), + } + } + + fn record_presented_frame( + &mut self, + frame: &FrameTiming, + presentation: &PresentTiming, + responded_to_input: bool, + ) { + let submitted_at = presentation.present_start; + let (Some(work), Some(is_late)) = (frame.work(submitted_at), frame.is_late(submitted_at)) + else { + self.frames_unmeasured += 1; + return; + }; + record_duration(&mut self.work, work); + if responded_to_input { + record_duration(&mut self.input_work, work); + } + self.missed_refreshes += frame.missed_refreshes(submitted_at).unwrap_or(0); + if is_late { + self.frames_late += 1; + self.input_frames_late += u64::from(responded_to_input); + } else { + self.frames_on_time += 1; + self.input_frames_on_time += u64::from(responded_to_input); + } + } +} + +/// Records `duration` in nanoseconds, growing the histogram as needed. +#[cfg(feature = "profiler")] +fn record_duration(histogram: &mut Histogram, duration: Duration) { + let nanos = u64::try_from(duration.as_nanos()).unwrap_or(u64::MAX); + if let Err(error) = histogram.record(nanos) { + log::error!("failed to record frame duration: {error}"); + } } /// A point-in-time snapshot of the input-latency histograms for a window, @@ -907,6 +1203,16 @@ pub struct WindowProfiler { last_present_at: Option, animating_at_last_present: bool, pending_frame: Option, + refresh_interval: Option, + frame_signal_at: Option, + by_refresh_interval: Vec, + /// Cloned for each new refresh interval's histograms, since creating one + /// can fail. + empty_histogram: Histogram, + draw_phases: DrawPhases, + /// For each view phase in progress, the time spent in views nested + /// inside it so far. + nested_view_time: SmallVec<[Duration; 16]>, } #[cfg(feature = "profiler")] @@ -938,6 +1244,13 @@ impl WindowProfiler { last_present_at: None, animating_at_last_present: false, pending_frame: None, + refresh_interval: None, + frame_signal_at: None, + by_refresh_interval: Vec::new(), + empty_histogram: Histogram::new(3) + .map_err(|error| anyhow::anyhow!("Failed to create frame histogram: {error}"))?, + draw_phases: DrawPhases::default(), + nested_view_time: SmallVec::new(), }; journal::record_frame_pending(window_id, Instant::now()); Ok(profiler) @@ -1022,6 +1335,18 @@ impl WindowProfiler { journal::end_foreground_turn(); } + /// Records when the frame signal for the frame the next draw will produce + /// fired. Coalesced signals report the first. + pub fn record_frame_signal(&mut self, signal_at: Option) { + self.frame_signal_at = signal_at; + } + + /// Sets the refresh interval of the window's display, which frames drawn + /// from now on are attributed to. + pub fn set_refresh_interval(&mut self, refresh_interval: Option) { + self.refresh_interval = refresh_interval; + } + /// Records the beginning of a window draw. pub fn begin_draw(&mut self) { journal::begin_foreground_turn(); @@ -1031,6 +1356,39 @@ impl WindowProfiler { .push(WindowActivity::Draw { started_at }); } + /// Records the phases of the window draw in progress. + pub fn record_draw_phases(&mut self, phases: DrawPhases) { + self.draw_phases = phases; + } + + /// Records the start of one phase of drawing a view, returning its start + /// time to pass to [`WindowProfiler::end_view`]. + pub fn begin_view(&mut self) -> Instant { + self.nested_view_time.push(Duration::ZERO); + Instant::now() + } + + /// Records the end of a view phase begun at `start`, journaling it when + /// its own work reached [`VIEW_TIMING_FLOOR`]. + pub fn end_view(&mut self, start: Instant, name: &'static str, phase: ViewPhase) { + let end = Instant::now(); + let duration = end.saturating_duration_since(start); + let nested = self.nested_view_time.pop().unwrap_or_default(); + if let Some(parent_nested) = self.nested_view_time.last_mut() { + *parent_nested += duration; + } + let self_duration = duration.saturating_sub(nested); + if self_duration >= VIEW_TIMING_FLOOR { + journal::record_view(ViewTiming { + name, + phase, + start, + end, + self_duration, + }); + } + } + /// Records the end of a window draw and returns the draw duration. pub fn end_draw(&mut self, dirty_at: Option, invalidations: u64) -> Duration { let Some(WindowActivity::Draw { @@ -1043,12 +1401,18 @@ impl WindowProfiler { }; let draw_end = Instant::now(); + // Taken even when the draw isn't recorded, so a later draw can't claim it. + let signal_at = self.frame_signal_at.take(); + let dirty_at = dirty_at.filter(|at| journal::frame_sample_is_valid(self.window_id, *at)); let frame_timing = FrameTiming { window_id: self.window_id, - dirty_at: dirty_at.filter(|at| journal::frame_sample_is_valid(self.window_id, *at)), + dirty_at, invalidations, draw_start, draw_end, + refresh_interval: self.refresh_interval, + signal_at, + phases: std::mem::take(&mut self.draw_phases), }; let draw_duration = frame_timing.draw_duration(); if !journal::power_interrupted_since(draw_start) { @@ -1060,8 +1424,8 @@ impl WindowProfiler { /// Records that a frame was presented. /// - /// `next_frame_scheduled` marks the animation state for the interval ending - /// at the next newly drawn frame's presentation. + /// `next_frame_scheduled` marks the animation state for the interval + /// ending at the next newly drawn frame's presentation. pub fn record_present( &mut self, present_start: Instant, @@ -1092,9 +1456,28 @@ impl WindowProfiler { dirty_to_present_histogram: self.dirty_to_present_histogram.clone(), draw_duration_histogram: self.draw_duration_histogram.clone(), present_interval_histogram: self.present_interval_histogram.clone(), + by_refresh_interval: self.by_refresh_interval.clone(), } } + fn frames_for(&mut self, refresh_interval: Option) -> &mut RefreshIntervalFrames { + let index = match self + .by_refresh_interval + .iter() + .position(|frames| frames.refresh_interval == refresh_interval) + { + Some(index) => index, + None => { + self.by_refresh_interval.push(RefreshIntervalFrames::new( + refresh_interval, + &self.empty_histogram, + )); + self.by_refresh_interval.len() - 1 + } + }; + &mut self.by_refresh_interval[index] + } + fn record_present_at( &mut self, present_start: Instant, @@ -1102,9 +1485,11 @@ impl WindowProfiler { window_active: bool, next_frame_scheduled: bool, ) { + let mut responded_to_input = false; if let Some(first_input_at) = self.first_input_at.take() && journal::frame_sample_is_valid(self.window_id, first_input_at) { + responded_to_input = true; let latency_nanos = present_end.duration_since(first_input_at).as_nanos() as u64; self.input_latency_histogram.record(latency_nanos).ok(); if self.pending_input_count > 0 { @@ -1144,6 +1529,8 @@ impl WindowProfiler { let Some(frame) = frame else { return; }; + self.frames_for(frame.refresh_interval) + .record_presented_frame(&frame, &present_timing, responded_to_input); if let Some(dirty_at) = frame.dirty_at && let Err(error) = self @@ -1166,6 +1553,9 @@ impl WindowProfiler { fn record_draw_timing(&mut self, timing: FrameTiming) { self.record_draw_duration(timing.draw_duration()); + let frames = self.frames_for(timing.refresh_interval); + frames.frames_drawn += 1; + record_duration(&mut frames.draw_duration, timing.draw_duration()); self.pending_frame = Some(timing); record_frame_event(FrameEvent::Draw(timing)); journal::record_draw(timing); @@ -1303,6 +1693,194 @@ mod tests { } } + #[test] + fn frame_work_starts_at_the_later_of_signal_and_invalidation() { + let refresh = Duration::from_millis(10); + let start = Instant::now(); + let at = |ms| start + Duration::from_millis(ms); + let frame_with = |dirty: Option, signal: Option| FrameTiming { + window_id: WindowId::from(1), + dirty_at: dirty.map(at), + invalidations: 1, + draw_start: at(1), + draw_end: at(2), + refresh_interval: Some(refresh), + signal_at: signal.map(at), + phases: Default::default(), + }; + let work = |dirty, signal| frame_with(dirty, signal).work(at(50)); + + // Waiting for the frame signal isn't work, however late it fires. + assert_eq!(work(Some(0), Some(8)), Some(Duration::from_millis(42))); + assert_eq!(work(Some(0), Some(40)), Some(Duration::from_millis(10))); + // A frame needed after its signal fired is measured from when it was + // needed. + assert_eq!(work(Some(5), Some(0)), Some(Duration::from_millis(45))); + // Animation frames have no invalidation to wait for. + assert_eq!(work(None, Some(0)), Some(Duration::from_millis(50))); + assert_eq!(work(Some(0), None), None); + + let frame = frame_with(Some(0), Some(0)); + for (submitted_ms, missed) in [(7, 0), (10, 0), (20, 1), (25, 2)] { + assert_eq!(frame.missed_refreshes(at(submitted_ms)), Some(missed)); + } + } + + #[test] + fn frames_are_split_by_refresh_interval_and_classified() { + let (_journal, _guard) = journal::install_test_foreground_journal(64, 4); + let mut profiler = WindowProfiler::new(WindowId::from(1)).expect("valid histograms"); + let sixty_hertz = Duration::from_secs(1) / 60; + let one_hundred_twenty_hertz = Duration::from_secs(1) / 120; + let three_hundred_sixty_hertz = Duration::from_secs(1) / 360; + let base = Instant::now(); + let at = |ms| base + Duration::from_millis(ms); + + struct Frame { + refresh_interval: Option, + signal_ms: Option, + present_start_ms: u64, + responded_to_input: bool, + } + let frames = [ + // On time, responding to input. + Frame { + refresh_interval: Some(sixty_hertz), + signal_ms: Some(1), + present_start_ms: 5, + responded_to_input: true, + }, + Frame { + refresh_interval: Some(sixty_hertz), + signal_ms: Some(0), + present_start_ms: 40, + responded_to_input: true, + }, + Frame { + refresh_interval: Some(sixty_hertz), + signal_ms: None, + present_start_ms: 5, + responded_to_input: false, + }, + // A late frame signal: only the 2 ms after it count. + Frame { + refresh_interval: Some(sixty_hertz), + signal_ms: Some(40), + present_start_ms: 42, + responded_to_input: false, + }, + Frame { + refresh_interval: Some(one_hundred_twenty_hertz), + signal_ms: Some(0), + present_start_ms: 12, + responded_to_input: false, + }, + // Misses refreshes but fits the budget floor. + Frame { + refresh_interval: Some(three_hundred_sixty_hertz), + signal_ms: Some(0), + present_start_ms: 6, + responded_to_input: false, + }, + Frame { + refresh_interval: Some(three_hundred_sixty_hertz), + signal_ms: Some(0), + present_start_ms: 9, + responded_to_input: false, + }, + Frame { + refresh_interval: None, + signal_ms: Some(0), + present_start_ms: 2, + responded_to_input: false, + }, + ]; + for frame in frames { + profiler.set_refresh_interval(frame.refresh_interval); + profiler.record_draw_timing(FrameTiming { + window_id: profiler.window_id, + dirty_at: Some(at(0)), + invalidations: 1, + draw_start: at(0), + draw_end: at(1), + refresh_interval: frame.refresh_interval, + signal_at: frame.signal_ms.map(at), + phases: Default::default(), + }); + if frame.responded_to_input { + profiler.first_input_at = Some(at(0)); + } + profiler.record_present_at( + at(frame.present_start_ms), + at(frame.present_start_ms + 1), + true, + false, + ); + } + + let snapshot = profiler.frame_duration_snapshot(); + let frames_for = |refresh_interval| { + snapshot + .by_refresh_interval + .iter() + .find(|frames| frames.refresh_interval == refresh_interval) + .cloned() + .expect("frames for the refresh interval") + }; + let work_buckets = |work: &Histogram, refresh_interval: Duration| { + histogram_bucket_counts( + work, + FRAME_WORK_BUCKETS_PERCENT + .map(|percent| (refresh_interval * percent as u32 / 100).as_nanos() as u64), + ) + }; + let sixty = frames_for(Some(sixty_hertz)); + assert_eq!(sixty.frames_drawn, 4); + assert_eq!(sixty.frames_on_time, 2); + assert_eq!(sixty.frames_late, 1); + // 40 ms of work at 16.7 ms per refresh. + assert_eq!(sixty.missed_refreshes, 2); + assert_eq!(sixty.frames_unmeasured, 1); + assert_eq!( + work_buckets(&sixty.work, sixty_hertz), + [2, 0, 0, 0, 0, 0, 1, 0] + ); + assert_eq!(sixty.input_frames_on_time, 1); + assert_eq!(sixty.input_frames_late, 1); + assert_eq!( + work_buckets(&sixty.input_work, sixty_hertz), + [1, 0, 0, 0, 0, 0, 1, 0] + ); + + let one_hundred_twenty = frames_for(Some(one_hundred_twenty_hertz)); + assert_eq!(one_hundred_twenty.frames_late, 1); + assert_eq!(one_hundred_twenty.missed_refreshes, 1); + assert_eq!(one_hundred_twenty.input_frames_late, 0); + + let three_hundred_sixty = frames_for(Some(three_hundred_sixty_hertz)); + assert_eq!(three_hundred_sixty.frames_on_time, 1); + assert_eq!(three_hundred_sixty.frames_late, 1); + // 6 ms of work misses 2 refreshes at 2.78 ms each, and 9 ms misses 3. + assert_eq!(three_hundred_sixty.missed_refreshes, 5); + + // Judged against the 60 Hz budget, without missed refreshes. + let unknown = frames_for(None); + assert_eq!(unknown.frames_drawn, 1); + assert_eq!(unknown.frames_on_time, 1); + assert_eq!(unknown.missed_refreshes, 0); + + let later = profiler.frame_duration_snapshot(); + let delta = later.by_refresh_interval[0].since(&snapshot.by_refresh_interval[0]); + assert_eq!( + delta.frames_drawn + delta.frames_on_time + delta.frames_late, + 0 + ); + assert_eq!( + delta.draw_duration.len() + delta.work.len() + delta.input_work.len(), + 0 + ); + } + #[test] fn records_draw_events_only_while_tracing() { let _trace_test_guard = TraceTestGuard::new(); @@ -1639,6 +2217,9 @@ mod tests { invalidations: 1, draw_start: draw_end - Duration::from_millis(2), draw_end, + refresh_interval: None, + signal_at: None, + phases: Default::default(), }); } } diff --git a/crates/gpui/src/profiler/hang.rs b/crates/gpui/src/profiler/hang.rs index fbd52341e30..827682c50fc 100644 --- a/crates/gpui/src/profiler/hang.rs +++ b/crates/gpui/src/profiler/hang.rs @@ -23,7 +23,7 @@ pub(crate) use monitor::HangMonitor; pub use monitor::{HangMonitorConfig, HangMonitorError, HangMonitorPoll, HangMonitorPollReason}; /// Version of the power/visibility-aware measurement rules. -pub const MEASUREMENT_VERSION: u32 = 2; +pub const MEASUREMENT_VERSION: u32 = 3; use super::SerializedLocation; use super::journal::{ @@ -42,6 +42,91 @@ pub struct HangDetector { threshold: Duration, frame_budget: Duration, first_present_at: Option, + activity: ActiveUse, +} + +/// The user counts as actively using the app for this long after deliberate +/// input. +pub const ACTIVE_USE_WINDOW: Duration = Duration::from_secs(60); + +/// Input that doesn't show the user is using the app: platforms deliver +/// pointer movement to background windows the pointer merely passes over. +const PASSIVE_INPUT_KINDS: [&str; 3] = ["mouse_move", "mouse_exited", "mouse_pressure"]; + +/// Accumulates the time the user was actively using the app: within +/// [`ACTIVE_USE_WINDOW`] of deliberate input, excluding stretches interrupted +/// by a system suspend. +#[derive(Default)] +struct ActiveUse { + /// End times of recent deliberate input, oldest first, for + /// [`Self::was_active_during`]. + recent_inputs: std::collections::VecDeque, + accounted_until: Option, + active_until: Option, + first_input_since_accounted: Option, + last_input_since_accounted: Option, + suspended: bool, +} + +impl ActiveUse { + fn observe(&mut self, entry: &ForegroundJournalEntry) { + match entry { + ForegroundJournalEntry::Event(ForegroundEvent::Input(input)) + if !PASSIVE_INPUT_KINDS.contains(&input.kind) => + { + self.recent_inputs.push_back(input.end); + self.first_input_since_accounted.get_or_insert(input.start); + self.last_input_since_accounted = Some( + self.last_input_since_accounted + .map_or(input.end, |last| last.max(input.end)), + ); + } + ForegroundJournalEntry::Boundary(IntervalBoundary::PowerTransition { .. }) => { + self.suspended = true; + } + _ => {} + } + } + + /// Whether the user was actively using the app at some point from + /// `start` to `end`: deliberate input during that span or within + /// [`ACTIVE_USE_WINDOW`] before it. + fn was_active_during(&self, start: Instant, end: Instant) -> bool { + let since = start.checked_sub(ACTIVE_USE_WINDOW).unwrap_or(start); + self.recent_inputs + .iter() + .any(|input| *input >= since && *input <= end) + } + + fn take(&mut self, now: Instant, max_elapsed: Duration) -> Duration { + // Incidents are judged soon after they end; inputs older than this + // can't be within the active window of anything still being sealed. + let retained_since = now.checked_sub(ACTIVE_USE_WINDOW * 10); + while self + .recent_inputs + .front() + .is_some_and(|input| retained_since.is_some_and(|since| *input < since)) + { + self.recent_inputs.pop_front(); + } + let since = self.accounted_until.replace(now); + let previous_until = self.active_until; + let first_input = self.first_input_since_accounted.take(); + if let Some(last_input) = self.last_input_since_accounted.take() { + let until = last_input + ACTIVE_USE_WINDOW; + self.active_until = Some(previous_until.map_or(until, |previous| previous.max(until))); + } + let (Some(since), false) = (since, std::mem::take(&mut self.suspended)) else { + return Duration::ZERO; + }; + let continued_until = previous_until.map_or(since, |until| until.min(now).max(since)); + let mut active = continued_until.duration_since(since); + if let (Some(first_input), Some(active_until)) = (first_input, self.active_until) { + let start = first_input.max(continued_until); + active += active_until.min(now).saturating_duration_since(start); + } + active.min(max_elapsed) + } } /// One sealed interval that contained at least one hang. @@ -52,11 +137,15 @@ pub struct HangIncident { pub snapshot: FrameSnapshot, /// Which detection rule qualified the interval. pub trigger: HangTrigger, - /// For [`HangTrigger::Threshold`], the events that blocked the foreground - /// for at least the detector's threshold, longest first. For - /// [`HangTrigger::Budget`], no event crossed the threshold and this instead - /// holds every event in the interval, longest first. + /// The events that caused the incident, longest first: those at least as + /// long as the threshold or the frame budget for [`HangTrigger::Threshold`] + /// and [`HangTrigger::BlockingWork`], and those overlapping the late frame's + /// work for [`HangTrigger::LateFrame`]. pub contributors: Vec, + /// Whether the user was actively using the app during the incident (see + /// [`HangDetector::take_active_time`]), so rates per active hour can count + /// only incidents that happened during it. + pub during_active_use: bool, } /// The detection rule that qualified an interval as a [`HangIncident`]. @@ -64,19 +153,38 @@ pub struct HangIncident { /// Recorded explicitly so consumers can separate the two classes without /// re-deriving them from `stall_ms`, which stops working whenever the /// detector's thresholds change. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)] #[serde(rename_all = "snake_case")] pub enum HangTrigger { /// A single event blocked the foreground for at least the hang threshold. Threshold, - /// No single event crossed the threshold, but the interval's total - /// foreground spend reached the frame budget. - Budget, + /// The interval presented a frame whose work exceeded its budget (see + /// [`FrameTiming::is_late`](crate::profiler::FrameTiming::is_late)). + LateFrame, + /// The interval presented no frame whose work could be measured, but a + /// single event blocked the foreground for at least the frame budget, + /// long enough to delay a frame. + BlockingWork, +} + +impl HangTrigger { + /// Every trigger. + pub const ALL: [Self; 3] = [Self::Threshold, Self::LateFrame, Self::BlockingWork]; + + /// The trigger's serialized name, e.g. `"late_frame"`. + pub fn as_str(self) -> &'static str { + match self { + Self::Threshold => "threshold", + Self::LateFrame => "late_frame", + Self::BlockingWork => "blocking_work", + } + } } impl HangDetector { - /// Creates a detector reporting single events at or above `threshold` - /// and intervals whose total foreground spend reached `frame_budget`. + /// Creates a detector reporting single events at or above `threshold`, + /// late frames, and blocking work of at least `frame_budget` (see + /// [`HangIncident::detect`]). /// Only events recorded from this point on are observed. pub fn new(journal: ForegroundJournal, threshold: Duration, frame_budget: Duration) -> Self { Self { @@ -85,9 +193,20 @@ impl HangDetector { threshold, frame_budget, first_present_at: None, + activity: ActiveUse::default(), } } + /// The time since the previous call that the user was actively using + /// the app, as of the journal entries polled so far: within + /// [`ACTIVE_USE_WINDOW`] of deliberate input, such as key presses, clicks, + /// and scrolling, excluding polls that observed a system + /// suspend. Capped at `max_elapsed`, so time this thread spent suspended + /// isn't counted. + pub fn take_active_time(&mut self, now: Instant, max_elapsed: Duration) -> Duration { + self.activity.take(now, max_elapsed) + } + /// When the first newly drawn frame observed by this detector finished /// platform submission. `None` until a presentation boundary is observed. pub fn first_present_at(&self) -> Option { @@ -98,6 +217,9 @@ impl HangDetector { /// the previous poll. pub fn poll(&mut self) -> Vec { let drained = self.collector.collect_unseen(); + for entry in &drained.entries { + self.activity.observe(entry); + } if self.first_present_at.is_none() { self.first_present_at = drained.entries.iter().find_map(|entry| match entry { ForegroundJournalEntry::Boundary(IntervalBoundary::Presented(presented)) => { @@ -110,7 +232,11 @@ impl HangDetector { .push_entries(drained.entries) .into_iter() .filter_map(|snapshot| { - HangIncident::detect(snapshot, self.threshold, self.frame_budget) + let mut incident = + HangIncident::detect(snapshot, self.threshold, self.frame_budget)?; + let (start, end) = incident.active_window(); + incident.during_active_use = self.activity.was_active_during(start, end); + Some(incident) }) .collect() } @@ -127,8 +253,11 @@ pub struct SerializedHangIncident { /// newly drawn frame finished platform submission (see /// [`HangDetector::first_present_at`]), otherwise `"steady"`. pub phase: &'static str, - /// `"threshold"` or `"budget"` (see [`HangTrigger`]). + /// `"threshold"`, `"late_frame"`, or `"blocking_work"` (see + /// [`HangTrigger`]). pub trigger: HangTrigger, + /// See [`HangIncident::during_active_use`]. + pub during_active_use: bool, /// When the incident's active window started, in milliseconds since app /// startup: the sealing frame's first invalidation, or the earliest /// contributor's start when nothing was pending a repaint. Foreground @@ -231,6 +360,28 @@ pub enum SerializedHangContributor { dirty_to_draw_ms: Option, /// Invalidations coalesced into the frame. invalidations: u64, + /// Time spent rendering views and requesting layout, in milliseconds. + request_layout_ms: f64, + /// Time spent computing layout and prepainting, in milliseconds. + prepaint_ms: f64, + /// Time spent painting, in milliseconds. + paint_ms: f64, + /// How many other events in the interval contain this one. + depth: usize, + }, + /// One phase of drawing a view whose own work took at least + /// [`crate::profiler::VIEW_TIMING_FLOOR`]. + View { + /// The view's type name. + name: &'static str, + /// The draw phase: `"request_layout"`, `"prepaint"`, or `"paint"`. + phase: &'static str, + /// When the phase started, in milliseconds since app startup. + start_ms: f64, + /// How long the phase took, including nested views, in milliseconds. + duration_ms: f64, + /// How long the phase took excluding nested views, in milliseconds. + self_ms: f64, /// How many other events in the interval contain this one. depth: usize, }, @@ -284,6 +435,7 @@ impl SerializedHangIncident { }, measurement_version: MEASUREMENT_VERSION, trigger: incident.trigger, + during_active_use: incident.during_active_use, start_ms: since_startup(active_start), active_ms: as_millis(active), stall_ms: incident @@ -378,6 +530,17 @@ impl SerializedHangContributor { duration_ms, dirty_to_draw_ms: timing.dirty_to_draw_duration().map(as_millis), invalidations: timing.invalidations, + request_layout_ms: as_millis(timing.phases.request_layout), + prepaint_ms: as_millis(timing.phases.prepaint), + paint_ms: as_millis(timing.phases.paint), + depth, + }, + ForegroundEvent::View(timing) => Self::View { + name: timing.name, + phase: timing.phase.as_str(), + start_ms: since_startup(timing.start), + duration_ms, + self_ms: as_millis(timing.self_duration), depth, }, ForegroundEvent::Present(timing) => Self::Present { @@ -428,41 +591,61 @@ impl HangIncident { (start, snapshot.interval_end()) } - /// Returns an incident when the snapshot contains at least one event - /// that blocked the foreground for `threshold` or longer, or when the - /// interval's total foreground spend — event time plus folded - /// small-poll time — reached `frame_budget` even though no single event - /// did. In the latter case every event in the interval becomes a - /// contributor, since no single stall explains the busy interval. + /// Returns an incident when the snapshot contains an event that blocked + /// the foreground for `threshold` or longer; otherwise when the interval + /// presented a late frame, unless the journal lost events; otherwise, when + /// no presented frame's work could be measured, when an event blocked the + /// foreground for `frame_budget` or longer. See [`HangTrigger`]. pub fn detect( snapshot: FrameSnapshot, threshold: Duration, frame_budget: Duration, ) -> Option { - let mut contributors: Vec = snapshot - .events - .iter() - .filter(|event| event.duration() >= threshold) - .copied() - .collect(); - let trigger = if contributors.is_empty() { - if snapshot.journal_discontinuous { - return None; - } - let spend = snapshot.occupancy_within(snapshot.interval_start, snapshot.interval_end()); - if spend < frame_budget { - return None; - } - contributors = snapshot.events.clone(); - HangTrigger::Budget - } else { + let events_at_least = |minimum: Duration| -> Vec { + snapshot + .events + .iter() + .filter(|event| event.duration() >= minimum) + .copied() + .collect() + }; + let mut contributors = events_at_least(threshold); + let measured_frame = match &snapshot.boundary { + IntervalBoundary::Presented(presented) => presented + .frame + .work_start() + .map(|work_start| (presented, work_start)), + _ => None, + }; + let trigger = if !contributors.is_empty() { HangTrigger::Threshold + } else if let Some((presented, work_start)) = measured_frame { + let submitted_at = presented.presentation.present_start; + if snapshot.journal_discontinuous + || !presented.frame.is_late(submitted_at).unwrap_or(false) + { + return None; + } + contributors = snapshot + .events + .iter() + .filter(|event| event.end_time() > work_start && event.start_time() < submitted_at) + .copied() + .collect(); + HangTrigger::LateFrame + } else { + contributors = events_at_least(frame_budget); + if contributors.is_empty() { + return None; + } + HangTrigger::BlockingWork }; contributors.sort_by_key(|event| std::cmp::Reverse(event.duration())); Some(Self { snapshot, trigger, contributors, + during_active_use: false, }) } } @@ -479,12 +662,14 @@ mod tests { use scheduler::SpawnTime; use crate::{ - self as gpui, Context, FocusHandle, InteractiveElement, IntoElement, Modifiers, - MouseButton, Render, Styled, TestAppContext, VisualTestContext, Window, WindowId, div, - point, px, + self as gpui, AnyView, AppContext as _, Context, FocusHandle, InteractiveElement, + IntoElement, Modifiers, MouseButton, ParentElement as _, Render, Styled, TestAppContext, + VisualTestContext, Window, WindowId, div, point, px, }; - use crate::profiler::{ActionTiming, FrameTiming, PresentTiming, TaskTiming, YieldTime}; + use crate::profiler::{ + ActionTiming, FrameTiming, PresentTiming, TaskTiming, ViewPhase, YieldTime, + }; use super::super::journal::{ FRAME_DEADLINE, ForegroundEvent, ForegroundJournalEntry, FrameSkipReason, FrameSkipped, @@ -511,14 +696,14 @@ mod tests { let at = |ms: u64| startup + Duration::from_millis(ms); let window_id = WindowId::from(1); for discontinuous in [false, true] { - for trigger in [HangTrigger::Threshold, HangTrigger::Budget] { + for trigger in [HangTrigger::Threshold, HangTrigger::BlockingWork] { let mut sealer = IntervalSealer::new(startup); let mut entries = Vec::new(); match trigger { HangTrigger::Threshold => entries.push(ForegroundJournalEntry::Event( task_poll_event(at(10), at(30)), )), - HangTrigger::Budget => entries.extend([ + _ => entries.extend([ ForegroundJournalEntry::Event(task_poll_event(at(10), at(16))), ForegroundJournalEntry::Event(task_poll_event(at(20), at(26))), ]), @@ -538,8 +723,8 @@ mod tests { panic!("expected one snapshot, got {snapshots:?}"); }; let incident = HangIncident::detect(snapshot.clone(), HANG_THRESHOLD, FRAME_BUDGET); - if discontinuous && trigger == HangTrigger::Budget { - assert!(incident.is_none(), "skips must not exempt journal gaps"); + if trigger == HangTrigger::BlockingWork { + assert!(incident.is_none(), "short work isn't blocking"); continue; } let incident = incident.expect("real work still qualifies across a skip"); @@ -645,11 +830,14 @@ mod tests { animation_interval: None, }; let frame = FrameTiming { + refresh_interval: None, + signal_at: None, window_id, dirty_at: Some(at(100)), invalidations: 3, draw_start: at(350), draw_end: at(380), + phases: Default::default(), }; let snapshot = FrameSnapshot { interval_start: at(150), @@ -957,11 +1145,14 @@ mod tests { interval_start: at(0), boundary: IntervalBoundary::Presented(PresentedFrame { frame: FrameTiming { + refresh_interval: None, + signal_at: Some(at(0)), window_id, dirty_at: Some(at(0)), invalidations: 1, draw_start: at(140), draw_end: at(145), + phases: Default::default(), }, presentation: PresentTiming { window_id, @@ -981,15 +1172,15 @@ mod tests { }; let incident = HangIncident::detect(snapshot, HANG_THRESHOLD, FRAME_BUDGET) - .expect("foreground spend exceeded the frame budget"); - assert_eq!(incident.trigger, HangTrigger::Budget); + .expect("the frame missed the 60 Hz budget used for unknown displays"); + assert_eq!(incident.trigger, HangTrigger::LateFrame); assert_eq!(incident.contributors.len(), 3); assert_eq!( incident.contributors[0].duration(), Duration::from_millis(8) ); let serialized = SerializedHangIncident::convert(startup, &incident, 8, Some(startup)); - assert_eq!(serialized.trigger, HangTrigger::Budget); + assert_eq!(serialized.trigger, HangTrigger::LateFrame); assert_eq!(serialized.stall_ms, 8.0); assert_eq!(serialized.dirty_to_present_ms, Some(150.0)); assert_eq!(serialized.sealed_by, "present"); @@ -1043,11 +1234,14 @@ mod tests { interval_start: at(0), boundary: IntervalBoundary::Presented(PresentedFrame { frame: FrameTiming { + refresh_interval: None, + signal_at: None, window_id, dirty_at: Some(at(0)), invalidations: 1, draw_start: at(145), draw_end: at(147), + phases: Default::default(), }, presentation: PresentTiming { window_id, @@ -1065,32 +1259,136 @@ mod tests { assert!(HangIncident::detect(snapshot, HANG_THRESHOLD, FRAME_BUDGET).is_none()); } - /// The budget applies to idle-sealed intervals too: a headless app (or - /// a stretch with no repaint pending) can still starve the foreground - /// with accumulated sub-threshold work. #[test] - fn an_idle_sealed_interval_over_budget_is_an_incident() { + fn active_use_counts_time_within_a_minute_of_deliberate_input() { + let start = scheduler::Instant::now(); + let at = |seconds: u64| start + Duration::from_secs(seconds); + let input_of_kind = |kind: &'static str, seconds: u64| { + ForegroundJournalEntry::Event(ForegroundEvent::Input(InputTiming { + kind, + start: at(seconds), + end: at(seconds), + caused_invalidation: true, + })) + }; + let input = |seconds: u64| input_of_kind("key_down", seconds); + let max = Duration::from_secs(10); + let mut activity = super::ActiveUse::default(); + assert_eq!(activity.take(at(0), max), Duration::ZERO); + // The pointer passing over a window isn't use. + activity.observe(&input_of_kind("mouse_move", 1)); + activity.observe(&input_of_kind("mouse_exited", 2)); + assert_eq!(activity.take(at(4), max), Duration::ZERO); + // Idle until input at 5 s. + activity.observe(&input(5)); + assert_eq!(activity.take(at(8), max), Duration::from_secs(3)); + // Active until 65 s, a minute after the input. + assert_eq!(activity.take(at(16), max), Duration::from_secs(8)); + for second in (24..=64).step_by(8) { + activity.take(at(second), max); + } + assert_eq!(activity.take(at(70), max), Duration::from_secs(1)); + assert_eq!(activity.take(at(78), max), Duration::ZERO); + // A suspend discards the poll it was observed in. + activity.observe(&input(80)); + activity.observe(&ForegroundJournalEntry::Boundary( + IntervalBoundary::PowerTransition { ended_at: at(81) }, + )); + assert_eq!(activity.take(at(84), max), Duration::ZERO); + assert_eq!(activity.take(at(88), max), Duration::from_secs(4)); + // Time the monitor itself was suspended isn't counted. + assert_eq!(activity.take(at(130), max), max); + + // Incidents spanning input or within a minute after it are during + // active use; ones later than that aren't. + assert!(activity.was_active_during(at(79), at(80))); + assert!(activity.was_active_during(at(100), at(101))); + assert!(!activity.was_active_during(at(141), at(142))); + assert!(!activity.was_active_during(at(66), at(70))); + } + + /// Without a measured frame, only a single event as long as the frame + /// budget is blocking work, however much short work the interval holds. + #[test] + fn only_single_events_over_the_frame_budget_are_blocking_work() { let startup = scheduler::Instant::now(); let at = |ms: u64| startup + Duration::from_millis(ms); - let snapshot = FrameSnapshot { + let snapshot = |longest_ms: u64| FrameSnapshot { interval_start: at(0), boundary: IntervalBoundary::Idle { ended_at: at(200) }, events: (0..10) .map(|i| task_poll_event(at(i * 20), at(i * 20 + 5))) + .chain([task_poll_event(at(200), at(200 + longest_ms))]) .collect(), small_polls: Vec::new(), dropped_events: 0, journal_discontinuous: false, }; + let frame_budget = Duration::from_millis(7); + assert!(HangIncident::detect(snapshot(6), HANG_THRESHOLD, frame_budget).is_none()); + let incident = HangIncident::detect(snapshot(7), HANG_THRESHOLD, frame_budget) + .expect("one event as long as the frame budget"); + assert_eq!(incident.trigger, HangTrigger::BlockingWork); + assert_eq!(incident.contributors.len(), 1); + } - let incident = HangIncident::detect(snapshot, HANG_THRESHOLD, FRAME_BUDGET) - .expect("foreground spend exceeded the frame budget"); - assert_eq!(incident.contributors.len(), 10); - let serialized = SerializedHangIncident::convert(startup, &incident, 8, Some(startup)); - assert_eq!(serialized.sealed_by, "idle"); - assert_eq!(serialized.dirty_to_present_ms, None); - assert_eq!(serialized.stall_ms, 5.0); - assert_eq!(serialized.contributors_elided, 2); + /// With a known refresh interval, a frame is a budget hang when its work, + /// from its frame signal to its submission, exceeded one refresh interval or + /// the 120 Hz floor, whichever is longer. + #[test] + fn late_frames_are_budget_hangs() { + let startup = scheduler::Instant::now(); + let at = |ms: u64| startup + Duration::from_millis(ms); + let window_id = WindowId::from(0xB0D6E7); + let detect = |refresh_interval: Duration, + signal_at: Option, + submitted_ms: u64| { + let snapshot = FrameSnapshot { + interval_start: at(0), + boundary: IntervalBoundary::Presented(PresentedFrame { + frame: FrameTiming { + window_id, + dirty_at: Some(at(0)), + invalidations: 1, + draw_start: at(1), + draw_end: at(submitted_ms - 1), + refresh_interval: Some(refresh_interval), + signal_at, + phases: Default::default(), + }, + presentation: PresentTiming { + window_id, + present_start: at(submitted_ms), + // Time spent inside the submission doesn't make + // the frame late. + present_end: at(submitted_ms + 50), + animation_interval: None, + }, + }), + events: vec![ + task_poll_event(at(1), at(6)), + task_poll_event(at(10), at(15)), + ], + small_polls: Vec::new(), + dropped_events: 0, + journal_discontinuous: false, + }; + HangIncident::detect(snapshot, HANG_THRESHOLD, FRAME_BUDGET) + }; + + let sixty_hertz = Duration::from_secs(1) / 60; + let incident = detect(sixty_hertz, Some(at(0)), 25).expect("work exceeded one refresh"); + assert_eq!(incident.trigger, HangTrigger::LateFrame); + assert_eq!(incident.contributors.len(), 2); + // Work from before the frame signal didn't delay the frame. + let incident = detect(sixty_hertz, Some(at(8)), 25).expect("17 ms of work at 60 Hz"); + assert_eq!(incident.contributors.len(), 1); + assert!(detect(sixty_hertz, Some(at(0)), 16).is_none()); + assert!(detect(sixty_hertz, None, 25).is_none()); + + let three_hundred_sixty_hertz = Duration::from_secs(1) / 360; + assert!(detect(three_hundred_sixty_hertz, Some(at(0)), 8).is_none()); + assert!(detect(three_hundred_sixty_hertz, Some(at(0)), 9).is_some()); } /// Contributors serialize in start order with their nesting depth: an @@ -1114,11 +1412,14 @@ mod tests { caused_invalidation: true, }), ForegroundEvent::Draw(FrameTiming { + refresh_interval: None, + signal_at: None, window_id, dirty_at: Some(at(0)), invalidations: 1, draw_start: at(1), draw_end: at(39), + phases: Default::default(), }), ], small_polls: Vec::new(), @@ -1145,55 +1446,6 @@ mod tests { )); } - /// Folded small polls count toward foreground spend, so an interval can - /// reach the budget with no retained events at all. The incident then - /// has no contributors and the small-poll summary carries the story. - #[test] - fn small_poll_spend_alone_can_reach_the_budget() { - let startup = scheduler::Instant::now(); - let at = |ms: u64| startup + Duration::from_millis(ms); - let window_id = WindowId::from(0xDE1A7); - let snapshot = FrameSnapshot { - interval_start: at(0), - boundary: IntervalBoundary::Presented(PresentedFrame { - frame: FrameTiming { - window_id, - dirty_at: Some(at(0)), - invalidations: 1, - draw_start: at(148), - draw_end: at(149), - }, - presentation: PresentTiming { - window_id, - present_start: at(149), - present_end: at(150), - animation_interval: None, - }, - }), - events: Vec::new(), - small_polls: vec![SmallPollFlush { - summary: PollSummary { - count: 40, - total: Duration::from_millis(12), - }, - since: at(0), - until: at(150), - }], - dropped_events: 0, - journal_discontinuous: false, - }; - - let incident = HangIncident::detect(snapshot, HANG_THRESHOLD, FRAME_BUDGET) - .expect("small-poll spend exceeded the frame budget"); - assert!(incident.contributors.is_empty()); - let serialized = SerializedHangIncident::convert(startup, &incident, 8, Some(startup)); - assert_eq!(serialized.stall_ms, 0.0); - assert_eq!(serialized.event_count, 0); - assert_eq!(serialized.small_poll_count, 40); - assert_eq!(serialized.dirty_to_present_ms, Some(150.0)); - assert_eq!(serialized.busy_fraction, 0.08); - } - proptest! { #![proptest_config(ProptestConfig { failure_persistence: None, @@ -1201,10 +1453,10 @@ mod tests { })] #[test] - fn detection_matches_threshold_and_budget_model_at_boundaries( + fn detection_matches_threshold_and_blocking_work_model_at_boundaries( durations_ms in prop::collection::vec(0u16..=50, 0..=16), threshold_ms in 0u16..=60, - frame_budget_ms in 0u16..=500, + frame_budget_ms in 0u16..=60, small_poll_total_ms in 0u16..=100, ) { let origin = scheduler::Instant::now(); @@ -1225,11 +1477,29 @@ mod tests { }) .collect::>(); let interval_end_ms = cursor_ms.max(1); + let interval_end = origin + Duration::from_millis(interval_end_ms); + // Without a frame signal, the frame's work can't be measured. + let window_id = WindowId::from(1); let snapshot = FrameSnapshot { interval_start: origin, - boundary: IntervalBoundary::Idle { - ended_at: origin + Duration::from_millis(interval_end_ms), - }, + boundary: IntervalBoundary::Presented(PresentedFrame { + frame: FrameTiming { + window_id, + dirty_at: Some(origin), + invalidations: 1, + draw_start: interval_end, + draw_end: interval_end, + refresh_interval: None, + signal_at: None, + phases: Default::default(), + }, + presentation: PresentTiming { + window_id, + present_start: interval_end, + present_end: interval_end, + animation_interval: None, + }, + }), events, small_polls: vec![SmallPollFlush { summary: PollSummary { @@ -1247,13 +1517,13 @@ mod tests { .copied() .filter(|duration| *duration >= threshold_ms) .collect::>(); - let occupancy_ms = durations_ms + let blocking_durations = durations_ms .iter() - .map(|duration| u64::from(*duration)) - .sum::() - + u64::from(small_poll_total_ms); + .copied() + .filter(|duration| *duration >= frame_budget_ms) + .collect::>(); let expected_incident = - !qualifying_durations.is_empty() || occupancy_ms >= u64::from(frame_budget_ms); + !qualifying_durations.is_empty() || !blocking_durations.is_empty(); let incident = HangIncident::detect( snapshot, @@ -1264,7 +1534,7 @@ mod tests { if let Some(incident) = incident { let mut expected_contributors = if qualifying_durations.is_empty() { - durations_ms + blocking_durations } else { qualifying_durations }; @@ -1400,6 +1670,92 @@ mod tests { } } + /// A slow view's draw is journaled under its type name with its own time, + /// excluding a slow view nested inside it, even when it's embedded through + /// an `AnyView`; fast phases aren't journaled, and the draw records how + /// long each of its phases took. + #[gpui::test] + fn slow_views_are_journaled_with_their_own_time(cx: &mut TestAppContext) { + let (journal, _journal_guard) = install_test_foreground_journal(1024, 16); + let mut collector = journal.collector(); + let (_view, cx) = cx.add_window_view(|_, cx| SlowParent { + child: cx.new(|_| SlowChild).into(), + }); + draw_window(cx); + + let events: Vec = collector + .collect_unseen() + .entries + .into_iter() + .filter_map(|entry| match entry { + ForegroundJournalEntry::Event(event) => Some(event), + _ => None, + }) + .collect(); + let view_timing = |suffix: &str, phase: ViewPhase| { + events + .iter() + .rev() + .find_map(|event| match event { + ForegroundEvent::View(timing) + if timing.name.ends_with(suffix) && timing.phase == phase => + { + Some(*timing) + } + _ => None, + }) + .unwrap_or_else(|| panic!("expected a {phase:?} timing for {suffix}")) + }; + let parent = view_timing("::SlowParent", ViewPhase::RequestLayout); + let child = view_timing("::SlowChild", ViewPhase::RequestLayout); + let parent_duration = parent.end.duration_since(parent.start); + let child_duration = child.end.duration_since(child.start); + assert!(child.self_duration >= SLOW_CHILD_RENDER); + assert!(parent.self_duration >= SLOW_PARENT_RENDER); + assert!(parent_duration >= child_duration + parent.self_duration); + assert!(!events.iter().any(|event| matches!( + event, + ForegroundEvent::View(timing) if timing.phase == ViewPhase::Paint + ))); + + let draw = events + .iter() + .rev() + .find_map(|event| match event { + ForegroundEvent::Draw(timing) => Some(*timing), + _ => None, + }) + .expect("a draw"); + assert!(draw.phases.request_layout >= SLOW_PARENT_RENDER + SLOW_CHILD_RENDER); + assert!( + draw.phases.request_layout + draw.phases.prepaint + draw.phases.paint + <= draw.draw_duration() + ); + } + + const SLOW_PARENT_RENDER: Duration = Duration::from_millis(3); + const SLOW_CHILD_RENDER: Duration = Duration::from_millis(2); + + struct SlowParent { + child: AnyView, + } + + impl Render for SlowParent { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + thread::sleep(SLOW_PARENT_RENDER); + div().size_full().child(self.child.clone()) + } + } + + struct SlowChild; + + impl Render for SlowChild { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + thread::sleep(SLOW_CHILD_RENDER); + div().size_full() + } + } + struct Injection { kind: HangKind, duration: Duration, @@ -1496,11 +1852,14 @@ mod tests { fn frame(window_id: WindowId, draw_end: scheduler::Instant) -> FrameTiming { FrameTiming { + refresh_interval: None, + signal_at: None, window_id, dirty_at: Some(draw_end - Duration::from_millis(2)), invalidations: 1, draw_start: draw_end - Duration::from_millis(1), draw_end, + phases: Default::default(), } } } diff --git a/crates/gpui/src/profiler/hang/monitor.rs b/crates/gpui/src/profiler/hang/monitor.rs index 566b32d3dc0..c8cb491af19 100644 --- a/crates/gpui/src/profiler/hang/monitor.rs +++ b/crates/gpui/src/profiler/hang/monitor.rs @@ -12,7 +12,9 @@ use super::{HangDetector, HangIncident}; pub struct HangMonitorConfig { /// Duration at which a single piece of foreground work counts as a hang. pub threshold: Duration, - /// Total foreground spend within one interval that counts as a hang. + /// Duration at which a single piece of foreground work counts as + /// blocking work in an interval without a measured frame (see + /// [`super::HangTrigger::BlockingWork`]). pub frame_budget: Duration, /// How often the monitor thread drains the journal. pub interval: Duration, @@ -45,6 +47,9 @@ pub struct HangMonitorPoll { pub incidents: Vec, /// See [`HangDetector::first_present_at`]. pub first_present_at: Option, + /// Time since the previous poll that the user was actively using the + /// app; see [`HangDetector::take_active_time`]. + pub active_time: Duration, /// Why this poll happened. pub reason: HangMonitorPollReason, } @@ -89,9 +94,11 @@ impl HangMonitor { Err(RecvTimeoutError::Disconnected) => break, }; let incidents = detector.poll(); + let active_time = detector.take_active_time(Instant::now(), interval * 2); on_poll(HangMonitorPoll { incidents, first_present_at: detector.first_present_at(), + active_time, reason, }); if let Some(done) = done { diff --git a/crates/gpui/src/profiler/journal.rs b/crates/gpui/src/profiler/journal.rs index fba75ae77ca..97d88852d7b 100644 --- a/crates/gpui/src/profiler/journal.rs +++ b/crates/gpui/src/profiler/journal.rs @@ -24,7 +24,7 @@ use std::time::Duration; use gpui_util::ResultExt; use scheduler::Instant; -use super::{ActionTiming, FrameTiming, PresentTiming, TaskTiming}; +use super::{ActionTiming, FrameTiming, PresentTiming, TaskTiming, ViewTiming}; use crate::{App, WindowId, WindowVisibility}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -84,6 +84,8 @@ pub enum ForegroundEvent { Input(InputTiming), /// A completed window draw. Draw(FrameTiming), + /// One phase of drawing a view, recorded during the draw that contains it. + View(ViewTiming), /// Work spent submitting a frame to the platform. Present(PresentTiming), /// Aggregate of task polls below [`TASK_POLL_FLOOR`], flushed before the @@ -100,6 +102,7 @@ impl ForegroundEvent { Self::Action(timing) => timing.start, Self::Input(timing) => timing.start, Self::Draw(timing) => timing.draw_start, + Self::View(timing) => timing.start, Self::Present(timing) => timing.present_start, Self::SmallPolls(flush) => flush.since, } @@ -112,6 +115,7 @@ impl ForegroundEvent { Self::Action(timing) => timing.end, Self::Input(timing) => timing.end, Self::Draw(timing) => timing.draw_end, + Self::View(timing) => timing.end, Self::Present(timing) => timing.present_end, Self::SmallPolls(flush) => flush.until, } @@ -1038,6 +1042,10 @@ pub(crate) fn record_input(timing: InputTiming) { with_journal(|journal| journal.record_event(ForegroundEvent::Input(timing))); } +pub(crate) fn record_view(timing: ViewTiming) { + with_journal(|journal| journal.record_event(ForegroundEvent::View(timing))); +} + pub(crate) fn record_draw(timing: FrameTiming) { with_journal(|journal| journal.record_event(ForegroundEvent::Draw(timing))); } @@ -1672,11 +1680,14 @@ mod tests { assert!(sealer.push_entries(entries).is_empty()); let frame = FrameTiming { + refresh_interval: None, + signal_at: None, window_id, dirty_at: Some(start), invalidations: 1, draw_start: start, draw_end: start + Duration::from_millis(20), + phases: Default::default(), }; record_draw(frame); record_present(presentation_timing(window_id, frame.draw_end), Some(frame)); @@ -1851,11 +1862,14 @@ mod tests { caused_invalidation: true, }; let frame = FrameTiming { + refresh_interval: None, + signal_at: None, window_id: WindowId::from(1), dirty_at: Some(input.start), invalidations: 1, draw_start: start + Duration::from_millis(3), draw_end: start + Duration::from_millis(4), + phases: Default::default(), }; let presentation = PresentTiming { window_id: frame.window_id, @@ -2698,6 +2712,7 @@ mod tests { ForegroundEvent::Draw(_) => 3, ForegroundEvent::Present(_) => 4, ForegroundEvent::SmallPolls(_) => 5, + ForegroundEvent::View(_) => 6, }; NormalizedEvent { kind, @@ -3483,11 +3498,14 @@ mod tests { fn frame_timing(window_id: WindowId, dirty_at: Instant, draw_end: Instant) -> FrameTiming { FrameTiming { + refresh_interval: None, + signal_at: None, window_id, dirty_at: Some(dirty_at), invalidations: 1, draw_start: draw_end, draw_end, + phases: Default::default(), } } diff --git a/crates/gpui/src/view.rs b/crates/gpui/src/view.rs index f24a4da9b79..081edd9a06b 100644 --- a/crates/gpui/src/view.rs +++ b/crates/gpui/src/view.rs @@ -24,6 +24,7 @@ use std::{ pub struct AnyView { entity: AnyEntity, render: fn(&AnyView, &mut Window, &mut App) -> AnyElement, + view_type_name: &'static str, } impl From> for AnyView { @@ -31,6 +32,7 @@ impl From> for AnyView { AnyView { entity: value.into_any(), render: any_view::render::, + view_type_name: type_name::(), } } } @@ -42,7 +44,7 @@ impl AnyView { /// [Context::notify] was called on the backing entity since it was rendered /// (or [Window::refresh] is called, which ignores caching). pub fn cached(self, style: StyleRefinement) -> ViewElement { - ViewElement::new(self).cached(style) + self.into_element().cached(style) } /// Convert this to a weak handle. @@ -50,6 +52,7 @@ impl AnyView { AnyWeakView { entity: self.entity.downgrade(), render: self.render, + view_type_name: self.view_type_name, } } @@ -61,6 +64,7 @@ impl AnyView { Err(entity) => Err(Self { entity, render: self.render, + view_type_name: self.view_type_name, }), } } @@ -101,7 +105,7 @@ impl IntoElement for Entity { type Element = ViewElement>; fn into_element(self) -> Self::Element { - ViewElement::new(self) + ViewElement::with_type_name(self, type_name::()) } #[inline(never)] @@ -114,7 +118,8 @@ impl IntoElement for AnyView { type Element = ViewElement; fn into_element(self) -> Self::Element { - ViewElement::new(self) + let view_type_name = self.view_type_name; + ViewElement::with_type_name(self, view_type_name) } } @@ -122,6 +127,7 @@ impl IntoElement for AnyView { pub struct AnyWeakView { entity: AnyWeakEntity, render: fn(&AnyView, &mut Window, &mut App) -> AnyElement, + view_type_name: &'static str, } impl AnyWeakView { @@ -131,6 +137,7 @@ impl AnyWeakView { Some(AnyView { entity, render: self.render, + view_type_name: self.view_type_name, }) } } @@ -140,6 +147,7 @@ impl From> for AnyWeakView { AnyWeakView { entity: view.into(), render: any_view::render::, + view_type_name: type_name::(), } } } @@ -240,7 +248,7 @@ impl Entity { /// uncached case. #[track_caller] pub fn cached(self, style: StyleRefinement) -> ViewElement> { - ViewElement::new(self).cached(style) + ViewElement::with_type_name(self, type_name::()).cached(style) } } @@ -251,6 +259,8 @@ pub struct ViewElement { view: Option, entity_id: Option, cached_style: Option, + #[cfg(feature = "profiler")] + view_type_name: &'static str, #[cfg(debug_assertions)] source: &'static core::panic::Location<'static>, } @@ -259,10 +269,20 @@ impl ViewElement { /// Wrap a [`View`] as an element. #[track_caller] pub fn new(view: V) -> Self { + Self::with_type_name(view, type_name::()) + } + + /// Wraps a view whose draw time profiling attributes to `view_type_name`, + /// such as an entity's type rather than [`Entity`]'s. + #[track_caller] + #[cfg_attr(not(feature = "profiler"), expect(unused_variables))] + pub(crate) fn with_type_name(view: V, view_type_name: &'static str) -> Self { let entity_id = view.entity_id(); ViewElement { entity_id, cached_style: None, + #[cfg(feature = "profiler")] + view_type_name, view: Some(view), #[cfg(debug_assertions)] source: core::panic::Location::caller(), @@ -330,14 +350,23 @@ impl Element for ViewElement { ) -> (LayoutId, Self::RequestLayoutState) { if let Some(entity_id) = self.entity_id { // Stateful path: create a reactive boundary. + #[cfg(feature = "profiler")] + let start = window.window_profiler.begin_view(); let view = &mut self.view; - request_layout_view( + let layout = request_layout_view( entity_id, self.cached_style.as_ref(), window, cx, &mut |window, cx| view.take().unwrap().render(window, cx).into_any_element(), - ) + ); + #[cfg(feature = "profiler")] + window.window_profiler.end_view( + start, + self.view_type_name, + crate::profiler::ViewPhase::RequestLayout, + ); + layout } else { // Stateless path: isolate subtree via type name (no entity identity). request_layout_component(type_name::(), window, cx, &mut |window, cx| { @@ -361,7 +390,9 @@ impl Element for ViewElement { ) -> Option { if let Some(entity_id) = self.entity_id { // Stateful path. - prepaint_view( + #[cfg(feature = "profiler")] + let start = window.window_profiler.begin_view(); + let prepainted = prepaint_view( entity_id, global_id, bounds, @@ -375,7 +406,14 @@ impl Element for ViewElement { .render(window, cx) .into_any_element() }, - ) + ); + #[cfg(feature = "profiler")] + window.window_profiler.end_view( + start, + self.view_type_name, + crate::profiler::ViewPhase::Prepaint, + ); + prepainted } else { // Stateless path: just prepaint the element. prepaint_component(type_name::(), element, window, cx) @@ -394,6 +432,8 @@ impl Element for ViewElement { ) { if let Some(entity_id) = self.entity_id { // Stateful path. + #[cfg(feature = "profiler")] + let start = window.window_profiler.begin_view(); paint_view( entity_id, self.cached_style.is_some(), @@ -402,6 +442,12 @@ impl Element for ViewElement { window, cx, ); + #[cfg(feature = "profiler")] + window.window_profiler.end_view( + start, + self.view_type_name, + crate::profiler::ViewPhase::Paint, + ); } else { // Stateless path: just paint the element. paint_component(std::any::type_name::(), element, window, cx); diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index 567da8f39e6..1214b0351a2 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -1277,7 +1277,7 @@ pub struct Window { /// Used to selectively enable VRR optimization only when input rate exceeds 60fps. pub(crate) input_rate_tracker: Rc>, #[cfg(feature = "profiler")] - window_profiler: profiler::WindowProfiler, + pub(crate) window_profiler: profiler::WindowProfiler, last_input_modality: InputModality, touch_gestures: TouchGestureRecognizer, touch_prediction_enabled: bool, @@ -1886,6 +1886,10 @@ impl Window { measure("frame duration", || { handle .update(&mut cx, |_, window, cx| { + #[cfg(feature = "profiler")] + window + .window_profiler + .record_frame_signal(request_frame_options.signal_at); if force_render { // Bypass cached view reuse so we don't replay stale // atlas tile references after a GPU device recovery. @@ -3561,6 +3565,8 @@ impl Window { #[cfg(feature = "profiler")] { + self.window_profiler + .set_refresh_interval(self.refresh_interval(cx)); let draw_duration = self .window_profiler .end_draw(frame_dirty.dirty_at, frame_dirty.invalidations); @@ -3691,8 +3697,12 @@ impl Window { // stretches to fill the viewport unless explicitly sized, window roots // fill the window when their size is `auto`. let scale_factor = self.scale_factor(); + #[cfg(feature = "profiler")] + let request_layout_start = Instant::now(); let mut root_element = self.root.as_ref().unwrap().clone().into_any_element(); let root_layout_id = root_element.request_layout(self, cx); + #[cfg(feature = "profiler")] + let prepaint_start = Instant::now(); self.layout_engine .as_mut() .unwrap() @@ -3730,6 +3740,8 @@ impl Window { self.mouse_hit_test = self.next_frame.hit_test(self.mouse_position); // Now actually paint the elements. + #[cfg(feature = "profiler")] + let paint_start = Instant::now(); self.invalidator.set_phase(DrawPhase::Paint); root_element.paint(self, cx); @@ -3749,6 +3761,14 @@ impl Window { #[cfg(any(feature = "inspector", debug_assertions))] self.paint_inspector_hitbox(cx); + #[cfg(feature = "profiler")] + self.window_profiler + .record_draw_phases(profiler::DrawPhases { + request_layout: prepaint_start.duration_since(request_layout_start), + prepaint: paint_start.duration_since(prepaint_start), + paint: Instant::now().duration_since(paint_start), + }); + // a11y may have been activated/deactivated halfway through the frame let a11y_active_start_of_frame = self.a11y.is_active(); self.a11y.sync_active_flag(); diff --git a/crates/hang_telemetry/Cargo.toml b/crates/hang_telemetry/Cargo.toml index 8555fcf66aa..1cebb2ba63a 100644 --- a/crates/hang_telemetry/Cargo.toml +++ b/crates/hang_telemetry/Cargo.toml @@ -14,7 +14,7 @@ doctest = false [dependencies] gpui = { workspace = true, features = ["profiler"] } -hdrhistogram.workspace = true log.workspace = true +serde.workspace = true serde_json.workspace = true telemetry_events.workspace = true diff --git a/crates/hang_telemetry/src/hang_telemetry.rs b/crates/hang_telemetry/src/hang_telemetry.rs index 97ed89f2614..f659580f694 100644 --- a/crates/hang_telemetry/src/hang_telemetry.rs +++ b/crates/hang_telemetry/src/hang_telemetry.rs @@ -12,10 +12,11 @@ use std::time::{Duration, Instant}; use gpui::App; use gpui::profiler::hang::{ - HangMonitorConfig, HangMonitorError, HangMonitorPoll, HangMonitorPollReason, HangTrigger, - MEASUREMENT_VERSION, SerializedHangIncident, + HangIncident, HangMonitorConfig, HangMonitorError, HangMonitorPoll, HangMonitorPollReason, + HangTrigger, MEASUREMENT_VERSION, SerializedHangIncident, }; -use hdrhistogram::Histogram; +use gpui::profiler::journal::ForegroundEvent; +use serde::Serialize; use serde_json::Value; use telemetry_events::FlexibleEvent; @@ -28,12 +29,29 @@ const MAX_SERIALIZED_CONTRIBUTORS: usize = 8; /// them all. const MAX_REPORTED_INCIDENTS: usize = 10; +/// Cap on the contributors summed across every incident in an event, kept by +/// total duration, so frequent causes show up even when no single incident +/// they're in is among the largest. +const MAX_REPORTED_CONTRIBUTOR_TOTALS: usize = 20; + +/// Cap on the distinct contributors tracked between sends, bounding memory +/// for sessions with many distinct slow tasks. +const MAX_TRACKED_CONTRIBUTORS: usize = 512; + // A long interval keeps hang telemetry a small fraction of event volume even // for pathologically hang-prone sessions; the on-quit flush covers short ones. const SEND_INTERVAL: Duration = Duration::from_mins(30); const MONITOR_INTERVAL: Duration = Duration::from_secs(1); +/// Upper bounds, in milliseconds, of the stall buckets each event reports. +/// Each bucket counts stalls up to and including its bound; a final bucket +/// counts longer ones. +const STALL_BUCKETS_MS: [u64; 8] = [50, 100, 250, 500, 1000, 2000, 5000, 10000]; + +/// Counts per [`STALL_BUCKETS_MS`] bucket, plus the final unbounded one. +type StallBuckets = [u64; STALL_BUCKETS_MS.len() + 1]; + /// Duration at which a single piece of foreground work counts as a hang. pub fn hang_threshold() -> Duration { if cfg!(debug_assertions) { @@ -49,16 +67,16 @@ pub fn hang_threshold() -> Duration { } } -/// Total foreground spend within one interval that counts as a hang. +/// Duration at which a single piece of foreground work counts as blocking +/// work when no frame's work was measured (see [`HangTrigger::BlockingWork`]). pub fn frame_budget() -> Duration { if cfg!(debug_assertions) { // Unoptimized builds routinely spend more than a release frame budget - // on ordinary frames; keep dev builds from reporting constantly. + // on ordinary work; keep dev builds from reporting constantly. Duration::from_millis(100) } else { - // At least one dropped frame on any display. Generous while budget - // incidents are plentiful; lower it as they get fixed. - Duration::from_millis(24) + // Long enough to delay a frame even at 60 Hz. + gpui::profiler::UNKNOWN_REFRESH_FRAME_BUDGET } } @@ -118,6 +136,10 @@ impl HangTelemetry { fn handle_poll(&mut self, poll: HangMonitorPoll) { let flush = poll.reason == HangMonitorPollReason::Flush; + let active_time = poll.active_time; + for incident in &poll.incidents { + self.reporter.add_contributors(incident); + } let incidents = serialize_incidents(self.startup, poll); if !incidents.is_empty() && let Some(observe_incidents) = self.observe_incidents.as_mut() @@ -127,6 +149,7 @@ impl HangTelemetry { for incident in incidents { self.reporter.add(incident); } + self.reporter.active_time += active_time; if flush || self.reporter.last_send.elapsed() > SEND_INTERVAL { (self.send_event)(self.reporter.take_event().into_flexible_event()); } @@ -150,10 +173,47 @@ fn serialize_incidents(startup: Instant, poll: HangMonitorPoll) -> Vec, - threshold_incidents: u64, - budget_incidents: u64, - /// Every incident's stall, in milliseconds; `pending` keeps only the largest. - stalls: Histogram, + incident_counts: IncidentCounts, + /// Every incident's stall, bucketed by [`STALL_BUCKETS_MS`]; `pending` + /// keeps only the largest incidents. + stall_buckets: StallBuckets, + stall_max_ms: u64, + /// See [`gpui::profiler::hang::HangDetector::take_active_time`]. + active_time: Duration, + contributor_totals: HashMap, + contributors_untracked: u64, +} + +/// Incidents and those during active use, by trigger. +type IncidentCounts = HashMap; + +/// One contributor's share of every incident since the last send. +#[derive(Clone, Debug, Default, PartialEq, Serialize)] +struct ContributorTotal { + /// See [`contributor_name`]. + name: String, + /// Incidents it contributed to. + incidents: u64, + /// Its total duration across those incidents, in milliseconds. Nested + /// work, such as a draw inside an input dispatch, counts toward both, + /// except that views count only their own work, excluding nested views. + total_ms: f64, +} + +/// What a contributor was, without timing: the action's name, where the task +/// was spawned, or the kind of input or frame work. +fn contributor_name(event: &ForegroundEvent) -> String { + match event { + ForegroundEvent::TaskPoll(timing) => { + format!("task:{}:{}", timing.location.file(), timing.location.line()) + } + ForegroundEvent::Action(timing) => format!("action:{}", timing.name), + ForegroundEvent::Input(timing) => format!("input:{}", timing.kind), + ForegroundEvent::Draw(_) => "draw".to_string(), + ForegroundEvent::View(timing) => format!("view:{}:{}", timing.name, timing.phase.as_str()), + ForegroundEvent::Present(_) => "present".to_string(), + ForegroundEvent::SmallPolls(_) => "small_polls".to_string(), + } } impl Reporter { @@ -161,18 +221,55 @@ impl Reporter { Self { last_send: Instant::now(), pending: Vec::new(), - threshold_incidents: 0, - budget_incidents: 0, - stalls: Histogram::new(3).expect("3 significant figures is a valid histogram"), + incident_counts: IncidentCounts::new(), + stall_buckets: StallBuckets::default(), + stall_max_ms: 0, + active_time: Duration::ZERO, + contributor_totals: HashMap::new(), + contributors_untracked: 0, + } + } + + fn add_contributors(&mut self, incident: &HangIncident) { + let mut counted = Vec::new(); + for event in &incident.contributors { + let name = contributor_name(event); + if !self.contributor_totals.contains_key(&name) + && self.contributor_totals.len() >= MAX_TRACKED_CONTRIBUTORS + { + self.contributors_untracked += 1; + continue; + } + let total = self + .contributor_totals + .entry(name.clone()) + .or_insert_with(|| ContributorTotal { + name: name.clone(), + ..ContributorTotal::default() + }); + let duration = match event { + ForegroundEvent::View(timing) => timing.self_duration, + _ => event.duration(), + }; + total.total_ms += duration.as_secs_f64() * 1000.0; + if !counted.contains(&name) { + total.incidents += 1; + counted.push(name); + } } } fn add(&mut self, incident: SerializedHangIncident) { - match incident.trigger { - HangTrigger::Threshold => self.threshold_incidents += 1, - HangTrigger::Budget => self.budget_incidents += 1, - } - self.stalls.record(incident.stall_ms as u64).ok(); + let (count, active_count) = self.incident_counts.entry(incident.trigger).or_default(); + *count += 1; + *active_count += u64::from(incident.during_active_use); + let stall_ms = incident.stall_ms.max(0.0).ceil() as u64; + let bucket = STALL_BUCKETS_MS + .iter() + .position(|bound| stall_ms <= *bound) + .unwrap_or(STALL_BUCKETS_MS.len()); + self.stall_buckets[bucket] += 1; + self.stall_max_ms = self.stall_max_ms.max(stall_ms); self.pending.push(incident); if self.pending.len() > MAX_REPORTED_INCIDENTS { self.pending @@ -187,59 +284,105 @@ impl Reporter { self.last_send = now; let mut incidents = std::mem::take(&mut self.pending); incidents.sort_by(|first, second| second.stall_ms.total_cmp(&first.stall_ms)); - let threshold_incidents = std::mem::take(&mut self.threshold_incidents); - let budget_incidents = std::mem::take(&mut self.budget_incidents); + let mut contributor_totals = std::mem::take(&mut self.contributor_totals) + .into_values() + .collect::>(); + contributor_totals.sort_by(|first, second| second.total_ms.total_cmp(&first.total_ms)); + let contributor_totals_elided = contributor_totals + .len() + .saturating_sub(MAX_REPORTED_CONTRIBUTOR_TOTALS) + as u64 + + std::mem::take(&mut self.contributors_untracked); + contributor_totals.truncate(MAX_REPORTED_CONTRIBUTOR_TOTALS); + for total in &mut contributor_totals { + total.total_ms = (total.total_ms * 1000.0).round() / 1000.0; + } let event = HangIncidentsEvent { incidents, - total_incidents: threshold_incidents + budget_incidents, - threshold_incidents, - budget_incidents, - stall_p50_ms: self.stalls.value_at_quantile(0.5), - stall_p95_ms: self.stalls.value_at_quantile(0.95), - stall_max_ms: self.stalls.max(), + incident_counts: std::mem::take(&mut self.incident_counts), + stall_buckets: std::mem::take(&mut self.stall_buckets), + stall_max_ms: std::mem::take(&mut self.stall_max_ms), report_window_seconds, + active_seconds: std::mem::take(&mut self.active_time).as_secs(), + contributor_totals, + contributor_totals_elided, }; - self.stalls.reset(); event } } struct HangIncidentsEvent { incidents: Vec, - /// Predates the threshold/budget split; existing queries key on it. - total_incidents: u64, - threshold_incidents: u64, - budget_incidents: u64, - stall_p50_ms: u64, - stall_p95_ms: u64, + /// Reported as `total_incidents`, `{trigger}_incidents`, and + /// `active_{trigger}_incidents` (those during active use). + incident_counts: IncidentCounts, + stall_buckets: StallBuckets, stall_max_ms: u64, report_window_seconds: u64, + /// Of `report_window_seconds`, how long the user was actively using the + /// app (within a minute of a key press, click, or scroll), for rates such + /// as hangs per active hour. + active_seconds: u64, + /// Contributors summed across every incident, not only the reported ones, + /// longest total first. + contributor_totals: Vec, + /// Contributors left out of `contributor_totals` by its cap, or untracked. + contributor_totals_elided: u64, } impl HangIncidentsEvent { fn into_flexible_event(self) -> FlexibleEvent { + let mut event_properties = HashMap::from([ + ("incidents".to_string(), to_value(&self.incidents)), + ("stall_max_ms".to_string(), self.stall_max_ms.into()), + ( + "report_window_seconds".to_string(), + self.report_window_seconds.into(), + ), + ("active_seconds".to_string(), self.active_seconds.into()), + ( + "contributor_totals".to_string(), + serde_json::to_value(&self.contributor_totals).unwrap_or_else(|error| { + log::error!("failed to serialize contributor totals: {error}"); + Value::Null + }), + ), + ( + "contributor_totals_elided".to_string(), + self.contributor_totals_elided.into(), + ), + ( + "measurement_version".to_string(), + MEASUREMENT_VERSION.into(), + ), + ]); + let mut total_incidents = 0; + for trigger in HangTrigger::ALL { + let (count, active_count) = self + .incident_counts + .get(&trigger) + .copied() + .unwrap_or_default(); + total_incidents += count; + let name = trigger.as_str(); + event_properties.insert(format!("{name}_incidents"), count.into()); + event_properties.insert(format!("active_{name}_incidents"), active_count.into()); + } + // Predates the split by trigger; existing queries key on it. + event_properties.insert("total_incidents".to_string(), total_incidents.into()); + for (index, count) in self.stall_buckets.iter().enumerate() { + let name = match STALL_BUCKETS_MS.get(index) { + Some(bound) => format!("stall_ms_le_{bound}"), + None => format!( + "stall_ms_gt_{}", + STALL_BUCKETS_MS.last().copied().unwrap_or_default() + ), + }; + event_properties.insert(name, (*count).into()); + } FlexibleEvent { event_type: EVENT_TYPE.to_string(), - event_properties: HashMap::from([ - ("incidents".to_string(), to_value(&self.incidents)), - ("total_incidents".to_string(), self.total_incidents.into()), - ( - "threshold_incidents".to_string(), - self.threshold_incidents.into(), - ), - ("budget_incidents".to_string(), self.budget_incidents.into()), - ("stall_p50_ms".to_string(), self.stall_p50_ms.into()), - ("stall_p95_ms".to_string(), self.stall_p95_ms.into()), - ("stall_max_ms".to_string(), self.stall_max_ms.into()), - ( - "report_window_seconds".to_string(), - self.report_window_seconds.into(), - ), - ( - "measurement_version".to_string(), - MEASUREMENT_VERSION.into(), - ), - ]), + event_properties, } } } @@ -259,13 +402,115 @@ mod tests { use super::*; use serde_json::json; + #[test] + fn reporter_sums_contributors_across_all_incidents() { + use gpui::profiler::{ActionTiming, journal::InputTiming}; + + let start = Instant::now(); + let at = |ms: u64| start + Duration::from_millis(ms); + let action = |name: &'static str, start_ms: u64, end_ms: u64| { + ForegroundEvent::Action(ActionTiming { + name, + start: at(start_ms), + end: at(end_ms), + }) + }; + let mut reporter = Reporter::new(); + for index in 0..30u64 { + let mut contributors = vec![ + action("editor::Paste", index * 100, index * 100 + 40), + ForegroundEvent::Input(InputTiming { + kind: "key_down", + start: at(index * 100), + end: at(index * 100 + 41), + caused_invalidation: true, + }), + ]; + if index == 0 { + // A name repeated within one incident counts as one incident. + contributors.push(action("editor::Paste", 50, 60)); + } + reporter.add_contributors(&incident_with_contributors(contributors)); + } + let event = reporter.take_event(); + + assert_eq!( + event.contributor_totals, + [ + ContributorTotal { + name: "input:key_down".to_string(), + incidents: 30, + total_ms: 1230.0, + }, + ContributorTotal { + name: "action:editor::Paste".to_string(), + incidents: 30, + total_ms: 1210.0, + }, + ] + ); + assert_eq!(event.contributor_totals_elided, 0); + assert!(reporter.take_event().contributor_totals.is_empty()); + } + + #[test] + fn reporter_totals_views_by_name_and_phase_using_their_own_time() { + use gpui::profiler::{ViewPhase, ViewTiming}; + + let start = Instant::now(); + let mut reporter = Reporter::new(); + reporter.add_contributors(&incident_with_contributors(vec![ForegroundEvent::View( + ViewTiming { + name: "markdown_preview::MarkdownPreviewView", + phase: ViewPhase::Prepaint, + start, + end: start + Duration::from_millis(12), + self_duration: Duration::from_millis(9), + }, + )])); + + assert_eq!( + reporter.take_event().contributor_totals, + [ContributorTotal { + name: "view:markdown_preview::MarkdownPreviewView:prepaint".to_string(), + incidents: 1, + total_ms: 9.0, + }] + ); + } + + #[test] + fn reporter_counts_incidents_during_active_use() { + let mut reporter = Reporter::new(); + for (trigger, during_active_use) in [ + (HangTrigger::Threshold, true), + (HangTrigger::Threshold, false), + (HangTrigger::LateFrame, true), + (HangTrigger::BlockingWork, false), + ] { + let mut incident = serialized_incident(120.0); + incident.trigger = trigger; + incident.during_active_use = during_active_use; + reporter.add(incident); + } + let event = reporter.take_event(); + assert_eq!( + event.incident_counts, + HashMap::from([ + (HangTrigger::Threshold, (2, 1)), + (HangTrigger::LateFrame, (1, 1)), + (HangTrigger::BlockingWork, (1, 0)), + ]) + ); + } + #[test] fn reporter_keeps_largest_incidents_and_counts_all() { let mut reporter = Reporter::new(); for stall_ms in 0..12 { let mut incident = serialized_incident(f64::from(stall_ms)); if stall_ms % 2 == 0 { - incident.trigger = HangTrigger::Budget; + incident.trigger = HangTrigger::LateFrame; } reporter.add(incident); } @@ -277,11 +522,14 @@ mod tests { .map(|incident| incident.stall_ms) .collect::>(); - assert_eq!(event.total_incidents, 12); - assert_eq!(event.threshold_incidents, 6); - assert_eq!(event.budget_incidents, 6); - assert_eq!(event.stall_p50_ms, 5); - assert_eq!(event.stall_p95_ms, 11); + assert_eq!( + event.incident_counts, + HashMap::from([ + (HangTrigger::Threshold, (6, 0)), + (HangTrigger::LateFrame, (6, 0)), + ]) + ); + assert_eq!(event.stall_buckets, [12, 0, 0, 0, 0, 0, 0, 0, 0]); assert_eq!(event.stall_max_ms, 11); assert_eq!( stalls, @@ -296,25 +544,22 @@ mod tests { reporter.take_event(); let mut incident = serialized_incident(20.9); - incident.trigger = HangTrigger::Budget; + incident.trigger = HangTrigger::LateFrame; reporter.add(incident); let event = reporter.take_event(); - assert_eq!(event.total_incidents, 1); - assert_eq!(event.threshold_incidents, 0); - assert_eq!(event.budget_incidents, 1); + assert_eq!( + event.incident_counts, + HashMap::from([(HangTrigger::LateFrame, (1, 0))]) + ); assert_eq!(event.incidents[0].stall_ms, 20.9); - assert_eq!(event.stall_p50_ms, 20); - assert_eq!(event.stall_p95_ms, 20); - assert_eq!(event.stall_max_ms, 20); + assert_eq!(event.stall_buckets, [1, 0, 0, 0, 0, 0, 0, 0, 0]); + assert_eq!(event.stall_max_ms, 21); let empty = reporter.take_event(); assert!(empty.incidents.is_empty()); - assert_eq!(empty.total_incidents, 0); - assert_eq!(empty.threshold_incidents, 0); - assert_eq!(empty.budget_incidents, 0); - assert_eq!(empty.stall_p50_ms, 0); - assert_eq!(empty.stall_p95_ms, 0); + assert!(empty.incident_counts.is_empty()); + assert_eq!(empty.stall_buckets, StallBuckets::default()); assert_eq!(empty.stall_max_ms, 0); } @@ -334,12 +579,26 @@ mod tests { "incidents": [], "total_incidents": 0, "threshold_incidents": 0, - "budget_incidents": 0, - "stall_p50_ms": 0, - "stall_p95_ms": 0, + "late_frame_incidents": 0, + "blocking_work_incidents": 0, "stall_max_ms": 0, + "stall_ms_le_50": 0, + "stall_ms_le_100": 0, + "stall_ms_le_250": 0, + "stall_ms_le_500": 0, + "stall_ms_le_1000": 0, + "stall_ms_le_2000": 0, + "stall_ms_le_5000": 0, + "stall_ms_le_10000": 0, + "stall_ms_gt_10000": 0, "report_window_seconds": report_window_seconds, - "measurement_version": 2 + "active_seconds": 0, + "active_threshold_incidents": 0, + "active_late_frame_incidents": 0, + "active_blocking_work_incidents": 0, + "contributor_totals": [], + "contributor_totals_elided": 0, + "measurement_version": 3 }) ); } @@ -348,13 +607,21 @@ mod tests { fn hang_incidents_event_uses_expected_wire_shape() { let event = HangIncidentsEvent { incidents: vec![serialized_incident(125.0)], - total_incidents: 3, - threshold_incidents: 2, - budget_incidents: 1, - stall_p50_ms: 25, - stall_p95_ms: 125, + incident_counts: HashMap::from([ + (HangTrigger::Threshold, (2, 1)), + (HangTrigger::LateFrame, (1, 1)), + (HangTrigger::BlockingWork, (1, 0)), + ]), + stall_buckets: [1, 0, 2, 0, 0, 0, 0, 0, 0], stall_max_ms: 125, report_window_seconds: 1800, + active_seconds: 900, + contributor_totals: vec![ContributorTotal { + name: "action:editor::Paste".to_string(), + incidents: 2, + total_ms: 250.5, + }], + contributor_totals_elided: 4, } .into_flexible_event(); @@ -363,9 +630,10 @@ mod tests { serde_json::to_value(event.event_properties).unwrap(), json!({ "incidents": [{ - "measurement_version": 2, + "measurement_version": 3, "phase": "steady", "trigger": "threshold", + "during_active_use": false, "start_ms": 10.0, "active_ms": 125.0, "stall_ms": 125.0, @@ -380,23 +648,59 @@ mod tests { "contributors": [], "contributors_elided": 0 }], - "total_incidents": 3, + "total_incidents": 4, "threshold_incidents": 2, - "budget_incidents": 1, - "stall_p50_ms": 25, - "stall_p95_ms": 125, + "late_frame_incidents": 1, + "blocking_work_incidents": 1, "stall_max_ms": 125, + "stall_ms_le_50": 1, + "stall_ms_le_100": 0, + "stall_ms_le_250": 2, + "stall_ms_le_500": 0, + "stall_ms_le_1000": 0, + "stall_ms_le_2000": 0, + "stall_ms_le_5000": 0, + "stall_ms_le_10000": 0, + "stall_ms_gt_10000": 0, "report_window_seconds": 1800, - "measurement_version": 2 + "active_seconds": 900, + "active_threshold_incidents": 1, + "active_late_frame_incidents": 1, + "active_blocking_work_incidents": 0, + "contributor_totals": [{ + "name": "action:editor::Paste", + "incidents": 2, + "total_ms": 250.5 + }], + "contributor_totals_elided": 4, + "measurement_version": 3 }) ); } + fn incident_with_contributors(contributors: Vec) -> HangIncident { + let start = Instant::now(); + HangIncident { + snapshot: gpui::profiler::journal::FrameSnapshot { + interval_start: start, + boundary: gpui::profiler::journal::IntervalBoundary::Idle { ended_at: start }, + events: contributors.clone(), + small_polls: Vec::new(), + dropped_events: 0, + journal_discontinuous: false, + }, + trigger: HangTrigger::Threshold, + contributors, + during_active_use: false, + } + } + fn serialized_incident(stall_ms: f64) -> SerializedHangIncident { SerializedHangIncident { measurement_version: MEASUREMENT_VERSION, phase: "steady", trigger: HangTrigger::Threshold, + during_active_use: false, start_ms: 10.0, active_ms: stall_ms, stall_ms, diff --git a/crates/input_latency_ui/Cargo.toml b/crates/input_latency_ui/Cargo.toml index 792f8fe107c..b2bfe9b81bc 100644 --- a/crates/input_latency_ui/Cargo.toml +++ b/crates/input_latency_ui/Cargo.toml @@ -18,4 +18,6 @@ chrono.workspace = true collections.workspace = true gpui = { workspace = true, features = ["profiler"] } hdrhistogram.workspace = true +serde_json.workspace = true +sysinfo.workspace = true telemetry.workspace = true diff --git a/crates/input_latency_ui/src/input_latency_ui.rs b/crates/input_latency_ui/src/input_latency_ui.rs index dced1380392..1ef104d621b 100644 --- a/crates/input_latency_ui/src/input_latency_ui.rs +++ b/crates/input_latency_ui/src/input_latency_ui.rs @@ -1,7 +1,13 @@ use collections::{HashMap, HashSet}; -use gpui::{App, FrameDurationSnapshot, Global, InputLatencySnapshot, Window, WindowId, actions}; +use gpui::{ + App, FRAME_DURATION_BUCKETS_MS, FRAME_WORK_BUCKETS_PERCENT, Global, InputLatencySnapshot, + RefreshIntervalFrames, Window, WindowId, actions, histogram_bucket_counts, +}; use hdrhistogram::Histogram; -use std::time::Instant; +use std::{ + sync::OnceLock, + time::{Duration, Instant}, +}; actions!( dev, @@ -140,158 +146,213 @@ pub fn report_input_latency_telemetry(window: &Window, cx: &mut App) { state.previous.insert(window_id, (now, current)); - let frames_sub4 = count_frames_in_range(&delta_latency, 0, MS4_NS); - let frames_4to8 = count_frames_in_range(&delta_latency, MS4_NS, MS8_NS); - let frames_8to16 = count_frames_in_range(&delta_latency, MS8_NS, MS16_NS); - let frames_16to33 = count_frames_in_range(&delta_latency, MS16_NS, MS33_NS); - let frames_33to100 = count_frames_in_range(&delta_latency, MS33_NS, MS100_NS); - // frames > 100 ms are implicitly total_frames - (sub4 + 4to8 + 8to16 + 16to33 + 33to100) - - let frames_with_1_event = count_frames_in_range(&delta_coalesce, 1, 2); - let frames_with_2_events = count_frames_in_range(&delta_coalesce, 2, 3); - let frames_with_3_events = count_frames_in_range(&delta_coalesce, 3, 4); - // frames with 4+ events are implicitly total_frames - (1 + 2 + 3) + // Frames over 100 ms, or with 4+ events, are implied by total_frames. + let latency_counts = + histogram_bucket_counts(&delta_latency, [MS4_NS, MS8_NS, MS16_NS, MS33_NS, MS100_NS]); + let coalesce_counts = histogram_bucket_counts(&delta_coalesce, [1, 2, 3]); + let latency = |index: usize| latency_counts.get(index).copied().unwrap_or_default(); + let coalesce = |index: usize| coalesce_counts.get(index).copied().unwrap_or_default(); telemetry::event!( "Latency Report", - frames_sub4 = frames_sub4, - frames_4to8 = frames_4to8, - frames_8to16 = frames_8to16, - frames_16to33 = frames_16to33, - frames_33to100 = frames_33to100, + frames_sub4 = latency(0), + frames_4to8 = latency(1), + frames_8to16 = latency(2), + frames_16to33 = latency(3), + frames_33to100 = latency(4), total_frames = total_frames, - frames_with_1_event = frames_with_1_event, - frames_with_2_events = frames_with_2_events, - frames_with_3_events = frames_with_3_events, + frames_with_1_event = coalesce(0), + frames_with_2_events = coalesce(1), + frames_with_3_events = coalesce(2), report_window_seconds = report_window_seconds, measurement_version = gpui::profiler::hang::MEASUREMENT_VERSION, ); } -/// Per-window baselines for frame-duration telemetry, keyed by window id. Kept -/// separate from the input-latency baselines so the two reports never share -/// state. +/// Per-window, per-refresh-interval baselines for frame-duration telemetry. +/// Kept separate from the input-latency baselines so the two reports never +/// share state. #[derive(Default)] struct FrameDurationTelemetryState { - previous: HashMap, + previous: HashMap<(WindowId, Option), (Instant, RefreshIntervalFrames)>, } impl Global for FrameDurationTelemetryState {} -/// Nanosecond boundaries for the present-interval buckets used in telemetry: -/// roughly the 120Hz, 60Hz, and 30Hz frame budgets, with headroom for jitter. -const MS9_NS: u64 = 9_000_000; -const MS18_NS: u64 = 18_000_000; -const MS36_NS: u64 = 36_000_000; - -/// Minimum number of draws that must be present in the delta window for the -/// frame-duration report to be sent. Avoids sending noise for windows that are -/// mostly idle. +/// Minimum number of draws at one refresh interval since its last report for +/// a frame-duration report to be sent. Avoids sending noise for windows that +/// are mostly idle. const MIN_DRAWS_TO_REPORT: u64 = 1_000; -/// Computes and sends a `Frame Duration Report` telemetry event for the given -/// window if enough frames were drawn since the last report. +/// Sends a `Frame Duration Report` telemetry event for each refresh interval +/// the given window drew enough frames at since its last report, so every +/// report describes frames on displays with one refresh rate. /// -/// The report contains bucketed draw durations (how long `Window::draw` took), -/// bucketed present intervals (the achieved frame-to-frame cadence while the -/// window was animating), and the average dirty-to-present duration. +/// Each report contains frame pacing (frames on time and late, missed +/// refreshes, and work per frame as a percentage of the refresh interval), the +/// same for frames that responded to input, and bucketed draw durations. +/// Buckets rather than percentiles, so reports can be summed. /// /// Call this periodically from a spawned task. pub fn report_frame_duration_telemetry(window: &Window, cx: &mut App) { - let current = window.frame_duration_snapshot(); + let snapshot = window.frame_duration_snapshot(); let window_handle = window.window_handle(); let window_id = window_handle.window_id(); + let gpu = window.gpu_specs(); let open_window_ids = open_window_ids(cx); let state = cx.default_global::(); state .previous - .retain(|window_id, _| open_window_ids.contains(window_id)); + .retain(|(window_id, _), _| open_window_ids.contains(window_id)); let now = Instant::now(); - let (delta_draws, delta_intervals, delta_dirty_to_present, report_window_seconds) = - if let Some((prev_instant, prev_snapshot)) = state.previous.get(&window_id) { - let mut delta_draws = current.draw_duration_histogram.clone(); - delta_draws - .subtract(&prev_snapshot.draw_duration_histogram) - .ok(); - let mut delta_intervals = current.present_interval_histogram.clone(); - delta_intervals - .subtract(&prev_snapshot.present_interval_histogram) - .ok(); - let mut delta_dirty_to_present = current.dirty_to_present_histogram.clone(); - if delta_dirty_to_present - .subtract(&prev_snapshot.dirty_to_present_histogram) - .is_err() - { - delta_dirty_to_present = current.dirty_to_present_histogram.clone(); - } - let elapsed = now.duration_since(*prev_instant).as_secs(); - ( - delta_draws, - delta_intervals, - delta_dirty_to_present, - elapsed, - ) - } else { - // First report for this window: the full cumulative histograms are - // the delta from the empty starting state. We don't know how long - // the window has been open, so record 0 to signal that this is the - // initial accumulation period rather than a fixed-width window. - ( - current.draw_duration_histogram.clone(), - current.present_interval_histogram.clone(), - current.dirty_to_present_histogram.clone(), - 0u64, - ) + for current in snapshot.by_refresh_interval { + let key = (window_id, current.refresh_interval); + let (frames, report_window_seconds) = match state.previous.get(&key) { + Some((previous_instant, previous)) => ( + current.since(previous), + now.duration_since(*previous_instant).as_secs(), + ), + // First report for this window and refresh interval: we don't know + // how long it has been accumulating, so record 0 to signal that + // this isn't a fixed-width window. + None => (current.clone(), 0), }; + if frames.frames_drawn < MIN_DRAWS_TO_REPORT { + continue; + } + state.previous.insert(key, (now, current)); - let total_draws = delta_draws.len(); - if total_draws < MIN_DRAWS_TO_REPORT { - return; + let mut properties = std::collections::HashMap::from_iter([ + ( + "refresh_interval_ms".to_string(), + serde_json::json!( + frames + .refresh_interval + .map(|interval| interval.as_secs_f64() * 1000.0) + ), + ), + ( + "refresh_rate_hz".to_string(), + serde_json::json!( + frames + .refresh_interval + .map(|interval| (1.0 / interval.as_secs_f64()).round() as u64) + ), + ), + ("frames_drawn".to_string(), frames.frames_drawn.into()), + ( + "input_frames_on_time".to_string(), + frames.input_frames_on_time.into(), + ), + ( + "input_frames_late".to_string(), + frames.input_frames_late.into(), + ), + ("frames_on_time".to_string(), frames.frames_on_time.into()), + ("frames_late".to_string(), frames.frames_late.into()), + ( + "missed_refreshes".to_string(), + frames.missed_refreshes.into(), + ), + ( + "frames_unmeasured".to_string(), + frames.frames_unmeasured.into(), + ), + ( + "gpu_name".to_string(), + serde_json::json!(gpu.as_ref().map(|gpu| gpu.device_name.clone())), + ), + ( + "gpu_is_software_emulated".to_string(), + serde_json::json!(gpu.as_ref().map(|gpu| gpu.is_software_emulated)), + ), + ("cpu_name".to_string(), serde_json::json!(cpu_name())), + ( + "root_entity_type_name".to_string(), + serde_json::json!(window_handle.root_entity_type_name()), + ), + ( + "report_window_seconds".to_string(), + report_window_seconds.into(), + ), + ( + "measurement_version".to_string(), + gpui::profiler::hang::MEASUREMENT_VERSION.into(), + ), + ]); + // Work buckets are relative to the refresh interval, so frames on + // displays with an unknown interval have none. + if let Some(refresh_interval) = frames.refresh_interval { + let work_bounds = FRAME_WORK_BUCKETS_PERCENT.map(|percent| { + u64::try_from(refresh_interval.as_nanos() * u128::from(percent) / 100) + .unwrap_or(u64::MAX) + }); + for (prefix, work) in [ + ("work_pct", &frames.work), + ("input_work_pct", &frames.input_work), + ] { + let counts = histogram_bucket_counts(work, work_bounds); + insert_buckets( + &mut properties, + prefix, + &FRAME_WORK_BUCKETS_PERCENT, + &counts, + ); + } + } + let draw_counts = histogram_bucket_counts( + &frames.draw_duration, + FRAME_DURATION_BUCKETS_MS.map(|milliseconds| milliseconds * 1_000_000), + ); + insert_buckets( + &mut properties, + "draw_ms", + &FRAME_DURATION_BUCKETS_MS, + &draw_counts, + ); + telemetry::send_event(telemetry::Event { + event_type: "Frame Duration Report".to_string(), + event_properties: properties, + }); } +} - state.previous.insert(window_id, (now, current)); +/// Inserts bucket counts as `{prefix}_le_{bound}` properties, plus +/// `{prefix}_gt_{last bound}` for the final, unbounded bucket. +fn insert_buckets( + properties: &mut std::collections::HashMap, + prefix: &str, + upper_bounds: &[u64], + counts: &[u64], +) { + for (index, count) in counts.iter().enumerate() { + let name = match upper_bounds.get(index) { + Some(bound) => format!("{prefix}_le_{bound}"), + None => format!( + "{prefix}_gt_{}", + upper_bounds.last().copied().unwrap_or_default() + ), + }; + properties.insert(name, (*count).into()); + } +} - let draws_sub4 = count_frames_in_range(&delta_draws, 0, MS4_NS); - let draws_4to8 = count_frames_in_range(&delta_draws, MS4_NS, MS8_NS); - let draws_8to16 = count_frames_in_range(&delta_draws, MS8_NS, MS16_NS); - let draws_16to33 = count_frames_in_range(&delta_draws, MS16_NS, MS33_NS); - // draws > 33ms are implicitly total_draws - (sub4 + 4to8 + 8to16 + 16to33) - - let total_intervals = delta_intervals.len(); - let intervals_sub9 = count_frames_in_range(&delta_intervals, 0, MS9_NS); - let intervals_9to18 = count_frames_in_range(&delta_intervals, MS9_NS, MS18_NS); - let intervals_18to36 = count_frames_in_range(&delta_intervals, MS18_NS, MS36_NS); - let intervals_36to100 = count_frames_in_range(&delta_intervals, MS36_NS, MS100_NS); - // intervals > 100ms are implicitly total_intervals - (the buckets above) - let average_present_interval_ms = delta_intervals.mean() / 1_000_000.0; - let average_dirty_to_present_ms = delta_dirty_to_present.mean() / 1_000_000.0; - - telemetry::event!( - "Frame Duration Report", - draws_sub4 = draws_sub4, - draws_4to8 = draws_4to8, - draws_8to16 = draws_8to16, - draws_16to33 = draws_16to33, - total_draws = total_draws, - intervals_sub9 = intervals_sub9, - intervals_9to18 = intervals_9to18, - intervals_18to36 = intervals_18to36, - intervals_36to100 = intervals_36to100, - total_intervals = total_intervals, - average_present_interval_ms = average_present_interval_ms, - average_dirty_to_present_ms = average_dirty_to_present_ms, - dirty_to_present_samples = delta_dirty_to_present.len(), - dirty_to_present_p50_ms = - delta_dirty_to_present.value_at_quantile(0.5) as f64 / 1_000_000.0, - dirty_to_present_p95_ms = - delta_dirty_to_present.value_at_quantile(0.95) as f64 / 1_000_000.0, - dirty_to_present_max_ms = delta_dirty_to_present.max() as f64 / 1_000_000.0, - root_entity_type_name = window_handle.root_entity_type_name(), - report_window_seconds = report_window_seconds, - measurement_version = gpui::profiler::hang::MEASUREMENT_VERSION, - ); +fn cpu_name() -> Option<&'static str> { + static CPU_NAME: OnceLock> = OnceLock::new(); + CPU_NAME + .get_or_init(|| { + let system = sysinfo::System::new_with_specifics( + sysinfo::RefreshKind::nothing().with_cpu(sysinfo::CpuRefreshKind::nothing()), + ); + system + .cpus() + .first() + .map(|cpu| cpu.brand().trim().to_string()) + .filter(|brand| !brand.is_empty()) + }) + .as_deref() } fn open_window_ids(cx: &App) -> HashSet { @@ -301,14 +362,6 @@ fn open_window_ids(cx: &App) -> HashSet { .collect() } -fn count_frames_in_range(histogram: &Histogram, low_ns: u64, high_ns: u64) -> u64 { - histogram - .iter_recorded() - .filter(|v| v.value_iterated_to() >= low_ns && v.value_iterated_to() < high_ns) - .map(|v| v.count_at_value()) - .sum() -} - fn format_report(data: &InputLatencyReportData) -> String { let snapshot = &data.snapshot; let histogram = &snapshot.latency_histogram;