From a1a25c155e1d6034cf76c5b9f65eff3b34c9832b Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:10:59 +0530 Subject: [PATCH 01/11] perf(project): resolve overlay stacks linearly and batch visible shape lookup --- crates/project/src/configuration.rs | 65 +++++++++++++++++++++++++++-- 1 file changed, 62 insertions(+), 3 deletions(-) diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rs index d7eb3c5772a..072ac5ed460 100644 --- a/crates/project/src/configuration.rs +++ b/crates/project/src/configuration.rs @@ -1,6 +1,6 @@ use std::{ borrow::Cow, - collections::BTreeMap, + collections::{BTreeMap, HashMap, HashSet}, fmt, io::Write, ops::{Add, Div, Mul, Sub, SubAssign}, @@ -3054,13 +3054,30 @@ impl ProjectConfiguration { pub fn resolved_overlay_order(&self, available: &[OverlayTrack]) -> Vec { let saved = self.overlay_order(); let mut ordered = Vec::with_capacity(available.len()); + if available.len() <= 24 && saved.len() <= 24 { + for track in available { + if !saved.contains(track) && !ordered.contains(track) { + ordered.push(*track); + } + } + for track in saved { + if available.contains(track) && !ordered.contains(track) { + ordered.push(*track); + } + } + return ordered; + } + + let saved_tracks: HashSet<_> = saved.iter().copied().collect(); + let available_tracks: HashSet<_> = available.iter().copied().collect(); + let mut included = HashSet::with_capacity(available_tracks.len()); for track in available { - if !saved.contains(track) && !ordered.contains(track) { + if !saved_tracks.contains(track) && included.insert(*track) { ordered.push(*track); } } for track in saved { - if available.contains(track) && !ordered.contains(track) { + if available_tracks.contains(track) && included.insert(*track) { ordered.push(*track); } } @@ -3118,6 +3135,48 @@ impl ProjectConfiguration { self.resolved_overlay_order(&available) } + pub fn visible_shape_order(&self, time: f64) -> Vec { + let Some(timeline) = &self.timeline else { + return Vec::new(); + }; + let segments = &timeline.shape_segments; + if segments.is_empty() || !time.is_finite() { + return Vec::new(); + } + + let shape_tracks: Vec<_> = self + .overlay_tracks() + .into_iter() + .rev() + .filter(|track| track.kind == OverlayTrackKind::Shape) + .map(|track| track.track) + .collect(); + + if let [track] = shape_tracks.as_slice() { + return segments + .iter() + .enumerate() + .filter(|(_, segment)| segment.track == *track && segment.is_active_at(time)) + .map(|(index, _)| index) + .collect(); + } + + let track_positions: HashMap<_, _> = shape_tracks + .iter() + .enumerate() + .map(|(position, track)| (*track, position)) + .collect(); + let mut grouped = vec![Vec::new(); shape_tracks.len()]; + for (index, segment) in segments.iter().enumerate() { + if segment.is_active_at(time) + && let Some(&position) = track_positions.get(&segment.track) + { + grouped[position].push(index); + } + } + grouped.into_iter().flatten().collect() + } + fn style_override_at( &self, time: f64, From c0ce4a3da2e8a6b31a4e401ba8013f1acd80f0da Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:11:09 +0530 Subject: [PATCH 02/11] perf(gpui): share one-pass overlay shape ordering with the project --- apps/desktop-gpui/src/editor_shapes.rs | 24 +----------------------- 1 file changed, 1 insertion(+), 23 deletions(-) diff --git a/apps/desktop-gpui/src/editor_shapes.rs b/apps/desktop-gpui/src/editor_shapes.rs index 032bbef5aab..a469358f4aa 100644 --- a/apps/desktop-gpui/src/editor_shapes.rs +++ b/apps/desktop-gpui/src/editor_shapes.rs @@ -847,29 +847,7 @@ impl EditorWindow { } pub(crate) fn visible_shape_order(&self, time: f64) -> Vec { - let segments = self.shape_segments(); - if segments.is_empty() { - return Vec::new(); - } - let mut order = Vec::new(); - for track in self - .project - .overlay_tracks() - .into_iter() - .rev() - .filter(|track| track.kind == cap_project::OverlayTrackKind::Shape) - { - order.extend( - segments - .iter() - .enumerate() - .filter(|(_, segment)| { - segment.track == track.track && segment.is_active_at(time) - }) - .map(|(index, _)| index), - ); - } - order + self.project.visible_shape_order(time) } /// Whether a text, image or mask box on a track stacked above the From e9b67ad785012db400554f4c17ba295e1b9770d9 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:12:10 +0530 Subject: [PATCH 03/11] test(project): prove overlay ordering preserves saved and shape semantics --- crates/project/src/configuration.rs | 167 ++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+) diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rs index 072ac5ed460..c34623cfb28 100644 --- a/crates/project/src/configuration.rs +++ b/crates/project/src/configuration.rs @@ -5763,6 +5763,173 @@ mod overlay_order_tests { } } +#[cfg(test)] +mod overlay_frame_order_tests { + use super::*; + + fn original_resolved_order( + available: &[OverlayTrack], + saved: &[OverlayTrack], + ) -> Vec { + let mut ordered = Vec::with_capacity(available.len()); + for track in available { + if !saved.contains(track) && !ordered.contains(track) { + ordered.push(*track); + } + } + for track in saved { + if available.contains(track) && !ordered.contains(track) { + ordered.push(*track); + } + } + ordered + } + + fn original_visible_shape_order(project: &ProjectConfiguration, time: f64) -> Vec { + let Some(timeline) = &project.timeline else { + return Vec::new(); + }; + let mut order = Vec::new(); + for track in project + .overlay_tracks() + .into_iter() + .rev() + .filter(|track| track.kind == OverlayTrackKind::Shape) + { + order.extend( + timeline + .shape_segments + .iter() + .enumerate() + .filter(|(_, segment)| { + segment.track == track.track && segment.is_active_at(time) + }) + .map(|(index, _)| index), + ); + } + order + } + + #[test] + fn overlay_order_is_identical_with_duplicates_and_stale_saved_tracks() { + for length in [0, 1, 7, 24, 25, 32, 128, 512] { + let available: Vec<_> = (0..length) + .map(|index| OverlayTrack { + kind: if index % 3 == 0 { + OverlayTrackKind::Shape + } else { + OverlayTrackKind::Text + }, + track: (index / 2) as u32, + }) + .collect(); + let mut saved: Vec<_> = available.iter().copied().step_by(3).rev().collect(); + saved.extend([ + OverlayTrack { + kind: OverlayTrackKind::Shape, + track: 65_535, + }, + saved.first().copied().unwrap_or(OverlayTrack { + kind: OverlayTrackKind::Mask, + track: 0, + }), + ]); + let mut project = ProjectConfiguration::default(); + project.set_overlay_order(saved.clone()); + assert_eq!( + project.resolved_overlay_order(&available), + original_resolved_order(&available, &saved), + "length={length}" + ); + project.set_overlay_order(Vec::new()); + assert_eq!( + project.resolved_overlay_order(&available), + original_resolved_order(&available, &[]), + "default length={length}" + ); + } + } + + #[test] + fn visible_shape_order_matches_track_by_track_scans_on_all_edges() { + let tracks = [0_u32, 7, 92, 4_096]; + let shapes: Vec<_> = (0..512) + .map(|index| { + let mut shape = crate::ShapeSegment::default(); + shape.track = tracks[(index * 13) % tracks.len()]; + shape.start = if index % 11 == 0 { 1.5 } else { 0. }; + shape.end = if index % 17 == 0 { -1. } else { 4. }; + shape.enabled = index % 9 != 0; + shape + }) + .collect(); + let mut timeline: TimelineConfiguration = serde_json::from_value(serde_json::json!({ + "segments": [], + "zoomSegments": [] + })) + .unwrap(); + timeline.shape_segments = shapes; + let mut project = ProjectConfiguration { + timeline: Some(timeline), + ..Default::default() + }; + + let shaped = |track| OverlayTrack { + kind: OverlayTrackKind::Shape, + track, + }; + for order in [ + vec![], + vec![shaped(4_096), shaped(0), shaped(92), shaped(7)], + vec![shaped(7), shaped(7), shaped(999_999), shaped(0)], + ] { + project.set_overlay_order(order); + for time in [ + f64::NEG_INFINITY, + -1., + 0., + 1.5, + 3.999, + 4., + f64::INFINITY, + f64::NAN, + ] { + assert_eq!( + project.visible_shape_order(time), + original_visible_shape_order(&project, time), + "time={time}" + ); + } + } + + project.timeline = None; + assert!(project.visible_shape_order(1.).is_empty()); + } + + #[test] + fn a_single_shape_track_keeps_source_order_and_ignores_inactive_segments() { + let mut timeline: TimelineConfiguration = serde_json::from_value(serde_json::json!({ + "segments": [], + "zoomSegments": [] + })) + .unwrap(); + timeline.shape_segments = (0..8) + .map(|index| { + let mut shape = crate::ShapeSegment::default(); + shape.track = 4; + shape.start = index as f64; + shape.end = index as f64 + 4.; + shape + }) + .collect(); + let project = ProjectConfiguration { + timeline: Some(timeline), + ..Default::default() + }; + assert_eq!(project.visible_shape_order(5.), vec![2, 3, 4, 5]); + } +} + #[cfg(test)] mod timeline_repair_tests { use super::*; From e93cced7617f24016c1945dfb38acc5e863adb05 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:12:59 +0530 Subject: [PATCH 04/11] bench(project): compare pre-optimization GPUI shape ordering end to end --- .../examples/gpui_shape_order_benchmark.rs | 183 ++++++++++++++++++ 1 file changed, 183 insertions(+) create mode 100644 crates/project/examples/gpui_shape_order_benchmark.rs diff --git a/crates/project/examples/gpui_shape_order_benchmark.rs b/crates/project/examples/gpui_shape_order_benchmark.rs new file mode 100644 index 00000000000..e8090838b94 --- /dev/null +++ b/crates/project/examples/gpui_shape_order_benchmark.rs @@ -0,0 +1,183 @@ +use cap_project::{ + OverlayTrack, OverlayTrackKind, ProjectConfiguration, ShapeSegment, TimelineConfiguration, +}; +use std::{hint::black_box, time::Instant}; + +fn previous_overlay_tracks(project: &ProjectConfiguration) -> Vec { + let Some(timeline) = &project.timeline else { + return Vec::new(); + }; + let mut available = Vec::new(); + for (kind, mut tracks) in [ + ( + OverlayTrackKind::Text, + timeline + .text_segments + .iter() + .map(|segment| segment.track) + .collect::>(), + ), + ( + OverlayTrackKind::Shape, + timeline + .shape_segments + .iter() + .map(|segment| segment.track) + .collect::>(), + ), + ( + OverlayTrackKind::Image, + timeline + .image_segments + .iter() + .map(|segment| segment.track) + .collect::>(), + ), + ( + OverlayTrackKind::Mask, + timeline + .mask_segments + .iter() + .map(|segment| segment.track) + .collect::>(), + ), + ] { + tracks.sort_unstable(); + tracks.dedup(); + available.extend( + tracks + .into_iter() + .rev() + .map(|track| OverlayTrack { kind, track }), + ); + } + let saved = project.overlay_order(); + let mut ordered = Vec::with_capacity(available.len()); + for track in &available { + if !saved.contains(track) && !ordered.contains(track) { + ordered.push(*track); + } + } + for track in saved { + if available.contains(track) && !ordered.contains(track) { + ordered.push(*track); + } + } + ordered +} + +fn previous_visible_shape_order(project: &ProjectConfiguration, time: f64) -> Vec { + let Some(timeline) = &project.timeline else { + return Vec::new(); + }; + let mut order = Vec::new(); + for track in previous_overlay_tracks(project) + .into_iter() + .rev() + .filter(|track| track.kind == OverlayTrackKind::Shape) + { + order.extend( + timeline + .shape_segments + .iter() + .enumerate() + .filter(|(_, segment)| { + segment.track == track.track && segment.is_active_at(time) + }) + .map(|(index, _)| index), + ); + } + order +} + +fn project_with_shapes(tracks: usize, shapes_per_track: usize) -> ProjectConfiguration { + let mut timeline: TimelineConfiguration = serde_json::from_value(serde_json::json!({ + "segments": [], + "zoomSegments": [] + })) + .unwrap(); + timeline.shape_segments = (0..tracks * shapes_per_track) + .map(|index| { + let mut segment = ShapeSegment::default(); + segment.track = ((index * 137) % tracks) as u32; + segment.start = 0.; + segment.end = 60.; + segment.enabled = index % 7 != 0; + segment + }) + .collect(); + let mut project = ProjectConfiguration { + timeline: Some(timeline), + ..Default::default() + }; + let mut saved: Vec<_> = (0..tracks) + .map(|index| OverlayTrack { + kind: OverlayTrackKind::Shape, + track: index as u32, + }) + .collect(); + saved.rotate_left(tracks / 4); + project.set_overlay_order(saved); + project +} + +fn measure(iterations: usize, mut run: impl FnMut()) -> f64 { + let start = Instant::now(); + for _ in 0..iterations { + run(); + } + start.elapsed().as_secs_f64() * 1_000_000. / iterations as f64 +} + +fn median(mut samples: Vec) -> f64 { + samples.sort_by(f64::total_cmp); + samples[samples.len() / 2] +} + +fn main() { + for (tracks, shapes_per_track, iterations) in [ + (1, 1_024, 500), + (16, 32, 200), + (64, 32, 40), + (128, 32, 15), + (256, 16, 10), + ] { + let project = project_with_shapes(tracks, shapes_per_track); + let time = 2.; + assert_eq!( + previous_visible_shape_order(&project, time), + project.visible_shape_order(time) + ); + for _ in 0..8 { + black_box(previous_visible_shape_order(black_box(&project), black_box(time))); + black_box(project.visible_shape_order(black_box(time))); + } + + let mut before = Vec::new(); + let mut after = Vec::new(); + for run in 0..9 { + if run % 2 == 0 { + before.push(measure(iterations, || { + black_box(previous_visible_shape_order(black_box(&project), black_box(time))); + })); + after.push(measure(iterations, || { + black_box(project.visible_shape_order(black_box(time))); + })); + } else { + after.push(measure(iterations, || { + black_box(project.visible_shape_order(black_box(time))); + })); + before.push(measure(iterations, || { + black_box(previous_visible_shape_order(black_box(&project), black_box(time))); + })); + } + } + let before = median(before); + let after = median(after); + println!( + "{{\"tracks\":{tracks},\"shapes\":{},\"baseline_p50_us\":{before:.2},\"optimized_p50_us\":{after:.2},\"speedup\":{:.2}}}", + tracks * shapes_per_track, + before / after + ); + } +} From 370713668664e4e8a08acd20cb1e74a7ce63c1e9 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:15:58 +0530 Subject: [PATCH 05/11] style: format benchmark for cargo fmt checks --- .../examples/gpui_shape_order_benchmark.rs | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/crates/project/examples/gpui_shape_order_benchmark.rs b/crates/project/examples/gpui_shape_order_benchmark.rs index e8090838b94..3f55130ee42 100644 --- a/crates/project/examples/gpui_shape_order_benchmark.rs +++ b/crates/project/examples/gpui_shape_order_benchmark.rs @@ -81,9 +81,7 @@ fn previous_visible_shape_order(project: &ProjectConfiguration, time: f64) -> Ve .shape_segments .iter() .enumerate() - .filter(|(_, segment)| { - segment.track == track.track && segment.is_active_at(time) - }) + .filter(|(_, segment)| segment.track == track.track && segment.is_active_at(time)) .map(|(index, _)| index), ); } @@ -149,7 +147,10 @@ fn main() { project.visible_shape_order(time) ); for _ in 0..8 { - black_box(previous_visible_shape_order(black_box(&project), black_box(time))); + black_box(previous_visible_shape_order( + black_box(&project), + black_box(time), + )); black_box(project.visible_shape_order(black_box(time))); } @@ -158,7 +159,10 @@ fn main() { for run in 0..9 { if run % 2 == 0 { before.push(measure(iterations, || { - black_box(previous_visible_shape_order(black_box(&project), black_box(time))); + black_box(previous_visible_shape_order( + black_box(&project), + black_box(time), + )); })); after.push(measure(iterations, || { black_box(project.visible_shape_order(black_box(time))); @@ -168,7 +172,10 @@ fn main() { black_box(project.visible_shape_order(black_box(time))); })); before.push(measure(iterations, || { - black_box(previous_visible_shape_order(black_box(&project), black_box(time))); + black_box(previous_visible_shape_order( + black_box(&project), + black_box(time), + )); })); } } From c9147584e5a7533903f064f59c80bbb0b525c59b Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:17:56 +0530 Subject: [PATCH 06/11] ci: run GPUI shape A/B benchmark on fork branch --- .../workflows/gpui-shape-bench-on-fork.yml | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 .github/workflows/gpui-shape-bench-on-fork.yml diff --git a/.github/workflows/gpui-shape-bench-on-fork.yml b/.github/workflows/gpui-shape-bench-on-fork.yml new file mode 100644 index 00000000000..ed382cb3cf9 --- /dev/null +++ b/.github/workflows/gpui-shape-bench-on-fork.yml @@ -0,0 +1,35 @@ +name: GPUI Shape Ordering Benchmark +on: + push: + branches: + - perf/gpui-shape-overlay-order + workflow_dispatch: +permissions: + contents: read +jobs: + benchmark: + runs-on: ubuntu-latest + timeout-minutes: 45 + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@1.95.0 + - name: Test overlay semantics + run: cargo test -p cap-project overlay_frame_order_tests -- --nocapture + - name: Check Rust formatting + run: cargo fmt --all -- --check + - name: Benchmark old vs optimized on same machine + run: | + set -o pipefail + cargo run --release -p cap-project --example gpui_shape_order_benchmark | tee gpui-shape-bench.jsonl + { + echo '### GPUI shape ordering A/B' + echo '' + echo '```json' + cat gpui-shape-bench.jsonl + echo '```' + } >> "$GITHUB_STEP_SUMMARY" + - uses: actions/upload-artifact@v4 + if: always() + with: + name: gpui-shape-order-bench + path: gpui-shape-bench.jsonl From 690c0b5a705a14debbb3cbc455c54bc21cf6f426 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:23:24 +0530 Subject: [PATCH 07/11] perf(gpui): preserve a linear-scan fast path for small shape overlays --- crates/project/src/configuration.rs | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rs index c34623cfb28..21d9caefd70 100644 --- a/crates/project/src/configuration.rs +++ b/crates/project/src/configuration.rs @@ -3152,13 +3152,23 @@ impl ProjectConfiguration { .map(|track| track.track) .collect(); - if let [track] = shape_tracks.as_slice() { - return segments - .iter() - .enumerate() - .filter(|(_, segment)| segment.track == *track && segment.is_active_at(time)) - .map(|(index, _)| index) - .collect(); + if shape_tracks.len() == 1 + || (shape_tracks.len() <= 16 + && segments.len().saturating_mul(shape_tracks.len()) <= 8_192) + { + let mut order = Vec::new(); + for track in shape_tracks { + order.extend( + segments + .iter() + .enumerate() + .filter(|(_, segment)| { + segment.track == track && segment.is_active_at(time) + }) + .map(|(index, _)| index), + ); + } + return order; } let track_positions: HashMap<_, _> = shape_tracks From fb7cdfd5f33ed20728eb0e96e63b92888bcb4156 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:24:20 +0530 Subject: [PATCH 08/11] chore: drop non-executable fork-only benchmark workflow --- .../workflows/gpui-shape-bench-on-fork.yml | 35 ------------------- 1 file changed, 35 deletions(-) delete mode 100644 .github/workflows/gpui-shape-bench-on-fork.yml diff --git a/.github/workflows/gpui-shape-bench-on-fork.yml b/.github/workflows/gpui-shape-bench-on-fork.yml deleted file mode 100644 index ed382cb3cf9..00000000000 --- a/.github/workflows/gpui-shape-bench-on-fork.yml +++ /dev/null @@ -1,35 +0,0 @@ -name: GPUI Shape Ordering Benchmark -on: - push: - branches: - - perf/gpui-shape-overlay-order - workflow_dispatch: -permissions: - contents: read -jobs: - benchmark: - runs-on: ubuntu-latest - timeout-minutes: 45 - steps: - - uses: actions/checkout@v4 - - uses: dtolnay/rust-toolchain@1.95.0 - - name: Test overlay semantics - run: cargo test -p cap-project overlay_frame_order_tests -- --nocapture - - name: Check Rust formatting - run: cargo fmt --all -- --check - - name: Benchmark old vs optimized on same machine - run: | - set -o pipefail - cargo run --release -p cap-project --example gpui_shape_order_benchmark | tee gpui-shape-bench.jsonl - { - echo '### GPUI shape ordering A/B' - echo '' - echo '```json' - cat gpui-shape-bench.jsonl - echo '```' - } >> "$GITHUB_STEP_SUMMARY" - - uses: actions/upload-artifact@v4 - if: always() - with: - name: gpui-shape-order-bench - path: gpui-shape-bench.jsonl From a3eb4a89bf83c4731f9f866d4bdba590ce3098f3 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:26:13 +0530 Subject: [PATCH 09/11] style: match rustfmt for shape fast-path filter --- crates/project/src/configuration.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rs index 21d9caefd70..72f9bfbdc78 100644 --- a/crates/project/src/configuration.rs +++ b/crates/project/src/configuration.rs @@ -3162,9 +3162,7 @@ impl ProjectConfiguration { segments .iter() .enumerate() - .filter(|(_, segment)| { - segment.track == track && segment.is_active_at(time) - }) + .filter(|(_, segment)| segment.track == track && segment.is_active_at(time)) .map(|(index, _)| index), ); } From eb24d255287ec498ab49fed244de6cfe7b01b2f5 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:01:20 +0530 Subject: [PATCH 10/11] perf(gpui): eliminate per-track shape allocations and protect small workloads --- crates/project/src/configuration.rs | 68 +++++++++++++++++++---------- 1 file changed, 45 insertions(+), 23 deletions(-) diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rs index 72f9bfbdc78..32782469da5 100644 --- a/crates/project/src/configuration.rs +++ b/crates/project/src/configuration.rs @@ -3069,15 +3069,14 @@ impl ProjectConfiguration { } let saved_tracks: HashSet<_> = saved.iter().copied().collect(); - let available_tracks: HashSet<_> = available.iter().copied().collect(); - let mut included = HashSet::with_capacity(available_tracks.len()); + let mut available_tracks: HashSet<_> = available.iter().copied().collect(); for track in available { - if !saved_tracks.contains(track) && included.insert(*track) { + if !saved_tracks.contains(track) && available_tracks.remove(track) { ordered.push(*track); } } for track in saved { - if available_tracks.contains(track) && included.insert(*track) { + if available_tracks.remove(track) { ordered.push(*track); } } @@ -3144,45 +3143,68 @@ impl ProjectConfiguration { return Vec::new(); } - let shape_tracks: Vec<_> = self - .overlay_tracks() - .into_iter() - .rev() + let tracks = self.overlay_tracks(); + let shape_count = tracks + .iter() .filter(|track| track.kind == OverlayTrackKind::Shape) - .map(|track| track.track) - .collect(); - - if shape_tracks.len() == 1 - || (shape_tracks.len() <= 16 - && segments.len().saturating_mul(shape_tracks.len()) <= 8_192) - { + .count(); + if shape_count == 0 { + return Vec::new(); + } + if shape_count <= 16 && segments.len().saturating_mul(shape_count) <= 8_192 { let mut order = Vec::new(); - for track in shape_tracks { + for track in tracks + .into_iter() + .rev() + .filter(|track| track.kind == OverlayTrackKind::Shape) + { order.extend( segments .iter() .enumerate() - .filter(|(_, segment)| segment.track == track && segment.is_active_at(time)) + .filter(|(_, segment)| { + segment.track == track.track && segment.is_active_at(time) + }) .map(|(index, _)| index), ); } return order; } - let track_positions: HashMap<_, _> = shape_tracks - .iter() + let track_positions: HashMap<_, _> = tracks + .into_iter() + .rev() + .filter(|track| track.kind == OverlayTrackKind::Shape) .enumerate() - .map(|(position, track)| (*track, position)) + .map(|(position, track)| (track.track, position)) .collect(); - let mut grouped = vec![Vec::new(); shape_tracks.len()]; + let missing = usize::MAX; + let mut first = vec![missing; shape_count]; + let mut last = vec![missing; shape_count]; + let mut next = vec![missing; segments.len()]; + let mut count = 0; for (index, segment) in segments.iter().enumerate() { if segment.is_active_at(time) && let Some(&position) = track_positions.get(&segment.track) { - grouped[position].push(index); + if last[position] == missing { + first[position] = index; + } else { + next[last[position]] = index; + } + last[position] = index; + count += 1; } } - grouped.into_iter().flatten().collect() + let mut ordered = Vec::with_capacity(count); + for start in first { + let mut index = start; + while index != missing { + ordered.push(index); + index = next[index]; + } + } + ordered } fn style_override_at( From fd509ec10322b869a7e00c43688ed07f914efed2 Mon Sep 17 00:00:00 2001 From: Himanshu Kumar <77563702+himanshu748@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:33:25 +0530 Subject: [PATCH 11/11] perf(gpui): protect sparse shape timelines and test grouping boundaries --- .../examples/gpui_shape_order_benchmark.rs | 7 ++ crates/project/src/configuration.rs | 94 ++++++++++++++++++- 2 files changed, 100 insertions(+), 1 deletion(-) diff --git a/crates/project/examples/gpui_shape_order_benchmark.rs b/crates/project/examples/gpui_shape_order_benchmark.rs index 3f55130ee42..73be9cb69ee 100644 --- a/crates/project/examples/gpui_shape_order_benchmark.rs +++ b/crates/project/examples/gpui_shape_order_benchmark.rs @@ -135,7 +135,14 @@ fn median(mut samples: Vec) -> f64 { fn main() { for (tracks, shapes_per_track, iterations) in [ (1, 1_024, 500), + (1, 8_193, 100), + (8, 1_032, 100), + (9, 920, 100), + (12, 768, 100), (16, 32, 200), + (16, 600, 100), + (17, 4, 150), + (17, 64, 100), (64, 32, 40), (128, 32, 15), (256, 16, 10), diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rs index 32782469da5..60f9c511035 100644 --- a/crates/project/src/configuration.rs +++ b/crates/project/src/configuration.rs @@ -3134,6 +3134,10 @@ impl ProjectConfiguration { self.resolved_overlay_order(&available) } + fn scan_shape_order_directly(shape_tracks: usize, segments: usize) -> bool { + shape_tracks <= 16 || shape_tracks.saturating_mul(segments) <= 32_768 + } + pub fn visible_shape_order(&self, time: f64) -> Vec { let Some(timeline) = &self.timeline else { return Vec::new(); @@ -3151,7 +3155,7 @@ impl ProjectConfiguration { if shape_count == 0 { return Vec::new(); } - if shape_count <= 16 && segments.len().saturating_mul(shape_count) <= 8_192 { + if Self::scan_shape_order_directly(shape_count, segments.len()) { let mut order = Vec::new(); for track in tracks .into_iter() @@ -5936,6 +5940,94 @@ mod overlay_frame_order_tests { assert!(project.visible_shape_order(1.).is_empty()); } + fn assert_visible_shape_order_matches_reference(tracks: &[u32], shape_count: usize) { + let mut timeline: TimelineConfiguration = serde_json::from_value(serde_json::json!({ + "segments": [], + "zoomSegments": [] + })) + .unwrap(); + timeline.shape_segments = (0..shape_count) + .map(|index| { + let mut shape = crate::ShapeSegment::default(); + shape.track = tracks[index % tracks.len()]; + shape.start = if index % 11 == 0 { 1.5 } else { 0. }; + shape.end = if index % 17 == 0 { -1. } else { 4. }; + shape.enabled = index % 9 != 0; + shape + }) + .collect(); + + let mut project = ProjectConfiguration { + timeline: Some(timeline), + ..Default::default() + }; + let mut custom_order: Vec<_> = tracks + .iter() + .rev() + .copied() + .map(|track| OverlayTrack { + kind: OverlayTrackKind::Shape, + track, + }) + .collect(); + custom_order.push(custom_order[0]); + custom_order.insert( + 1, + OverlayTrack { + kind: OverlayTrackKind::Shape, + track: 999_999, + }, + ); + for order in [vec![], custom_order] { + project.set_overlay_order(order); + for time in [ + f64::NEG_INFINITY, + -1., + 0., + 1.5, + 3.999, + 4., + f64::INFINITY, + f64::NAN, + ] { + assert_eq!( + project.visible_shape_order(time), + original_visible_shape_order(&project, time), + "tracks={} shapes={shape_count} time={time}", + tracks.len() + ); + } + } + } + + #[test] + fn shape_order_dispatch_preserves_low_track_count_scans() { + assert!(ProjectConfiguration::scan_shape_order_directly(1, 8_193)); + assert!(ProjectConfiguration::scan_shape_order_directly(8, 8_256)); + assert!(ProjectConfiguration::scan_shape_order_directly(16, 9_600)); + assert!(ProjectConfiguration::scan_shape_order_directly(17, 68)); + assert!(ProjectConfiguration::scan_shape_order_directly(17, 1_927)); + assert!(!ProjectConfiguration::scan_shape_order_directly(17, 1_928)); + assert!(!ProjectConfiguration::scan_shape_order_directly(64, 2_048)); + + assert_visible_shape_order_matches_reference(&[92], 8_193); + assert_visible_shape_order_matches_reference( + &[0, 7, 92, 4_096, 10_000, 11_000, 12_000, 13_000], + 8_256, + ); + let sixteen_tracks: Vec = (0..16).map(|index| index * 131 + 7).collect(); + assert_visible_shape_order_matches_reference(&sixteen_tracks, 9_600); + } + + #[test] + fn grouping_matches_reference_with_sparse_tracks_and_custom_stacking() { + let seventeen_tracks: Vec = (0..17).map(|index| index * 113 + 7).collect(); + assert_visible_shape_order_matches_reference(&seventeen_tracks, 68); + assert_visible_shape_order_matches_reference(&seventeen_tracks, 2_048); + let sixty_four_tracks: Vec = (0..64).map(|index| index * 113 + 7).collect(); + assert_visible_shape_order_matches_reference(&sixty_four_tracks, 2_048); + } + #[test] fn a_single_shape_track_keeps_source_order_and_ignores_inactive_segments() { let mut timeline: TimelineConfiguration = serde_json::from_value(serde_json::json!({