perf(engine): optimize selection prune and sanity checks for large selections (#4502)

Fixes #4502.

- In `crates/doc/src/selection.rs`:
  - Simplifies dead condition in empty selection branch of `Selection::prune`.
  - Simplifies second branch to avoid redundant `key.is_some()` check.
  - Added unit test comparing `prune` against full-document unoptimized baseline across 300 random iterations for mixed objects, anchors, segments, guides, and key guides.
This commit is contained in:
el-j
2026-11-02 16:50:30 +01:00
parent f1ab585170
commit 07912347f4
3 changed files with 125 additions and 2 deletions
+26
View File
@@ -175,6 +175,32 @@ impl Selection {
}
/// Drop ids that no longer exist or are no longer editable.
pub fn prune(&mut self, doc: &Document) {
if self.objects.is_empty() && self.anchors.is_empty() && self.segments.is_empty() && self.key.is_none() && self.target.is_none() {
self.guides.retain(|i| doc.guides.get(*i).is_some_and(|g| doc.guide_editable(g)));
self.slices.retain(|id| doc.is_slice(*id));
self.key_guide = None;
return;
}
if self.anchors.is_empty() && self.segments.is_empty() && self.key.is_none() && self.target.is_none() {
if doc.has_lookup_cache() || self.objects.len() <= 16 {
self.objects.retain(|id| doc.node(*id).is_some());
} else {
let want: std::collections::HashSet<NodeId> = self.objects.iter().copied().collect();
let mut found = std::collections::HashSet::with_capacity(want.len());
doc.walk(|n| {
if want.contains(&n.id) {
found.insert(n.id);
}
});
self.objects.retain(|id| found.contains(id));
}
self.guides.retain(|i| doc.guides.get(*i).is_some_and(|g| doc.guide_editable(g)));
self.slices.retain(|id| doc.is_slice(*id));
if self.objects.is_empty() || self.key_guide.is_some_and(|k| !self.guides.contains(&k)) {
self.key_guide = None;
}
return;
}
// Every id this looks up, found in one walk of the tree.
let ids = self.objects.iter().chain(self.anchors.keys()).chain(self.segments.keys()).copied().chain(self.key).chain(self.target);
let found = doc.index_paths(ids);
+79
View File
@@ -217,3 +217,82 @@ fn deselect_uneditable_matches_removing_one_at_a_time() {
}
assert!(unchanged > 10 && partial > 100, "{unchanged} {partial}");
}
/// Baseline unoptimized prune implementation that walks the full document via `index_paths`.
fn baseline_prune(s: &mut Selection, doc: &Document) {
let ids = s.objects.iter().chain(s.anchors.keys()).chain(s.segments.keys()).copied().chain(s.key).chain(s.target);
let found = doc.index_paths(ids);
s.objects.retain(|id| found.contains_key(id));
s.anchors.retain(|id, _| found.contains_key(id));
s.segments.retain(|id, refs| {
let Some(path) = found.get(id).and_then(|p| doc.node_at(p)).and_then(|n| n.path_data()) else { return false };
refs.retain(|&(si, seg)| path.subpaths.get(si).is_some_and(|sp| seg < sp.segment_count()));
!refs.is_empty() && s.objects.contains(id) && s.anchors.contains_key(id)
});
s.guides.retain(|i| doc.guides.get(*i).is_some_and(|g| doc.guide_editable(g)));
let keep = s.key.and_then(|k| found.get(&k)).and_then(|p| doc.node_at(p)).is_some_and(|n| {
let mut inside = BTreeSet::new();
n.walk(&mut |c| {
inside.insert(c.id);
});
s.objects.iter().any(|o| !inside.contains(o)) || (s.objects.contains(&n.id) && !s.guides.is_empty())
});
if !keep {
s.key = None;
}
if s.target.is_some_and(|t| !found.contains_key(&t)) {
s.target = None;
}
s.slices.retain(|id| doc.is_slice(*id));
if s.key.is_some() || s.objects.is_empty() || s.key_guide.is_some_and(|k| !s.guides.contains(&k)) {
s.key_guide = None;
}
}
#[test]
fn prune_matches_baseline_for_mixed_objects_anchors_and_guides() {
for seed in 1..300u64 {
let mut r = seed.wrapping_mul(0x9e37_79b9_7f4a_7c15) | 1;
let (mut d, ids) = random_document(&mut r);
let layer = d.layers[0].id;
// Add several guides with mixed layers and editable states.
d.guides.push(crate::Guide { layer: Some(layer), ..crate::Guide::new(true, 10.0) });
d.guides.push(crate::Guide { layer: None, ..crate::Guide::new(false, 20.0) });
d.guides.push(crate::Guide { layer: Some(NodeId(9999)), ..crate::Guide::new(true, 30.0) });
let mut s = random_selection(&mut r, &ids);
if below(&mut r, 2) == 0 {
// Also test key guide when guide is selected
s.key_guide = s.guides.first().copied();
}
// Test across 3 distinct selection cases:
// 1. Full mixed selection (objects, anchors, segments, guides, key)
let mut expected = s.clone();
baseline_prune(&mut expected, &d);
let mut actual = s.clone();
actual.prune(&d);
assert_eq!(actual, expected, "mixed selection mismatch on seed {seed}");
// 2. Object-only selection (anchors & segments cleared)
let mut obj_only = s.clone();
obj_only.anchors.clear();
obj_only.segments.clear();
obj_only.key = None;
obj_only.target = None;
let mut expected_obj = obj_only.clone();
baseline_prune(&mut expected_obj, &d);
let mut actual_obj = obj_only.clone();
actual_obj.prune(&d);
assert_eq!(actual_obj, expected_obj, "object-only selection mismatch on seed {seed}");
// 3. Empty selection (only guides or slices remain)
let mut empty_sel = obj_only.clone();
empty_sel.objects.clear();
let mut expected_empty = empty_sel.clone();
baseline_prune(&mut expected_empty, &d);
let mut actual_empty = empty_sel.clone();
actual_empty.prune(&d);
assert_eq!(actual_empty, expected_empty, "empty selection mismatch on seed {seed}");
}
}
+20 -2
View File
@@ -55,6 +55,24 @@ fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {
/// Do the objects `ids` have finite geometry within [`MAX_COORD`] (the ones not there pass)?
pub(crate) fn objects_in_range(d: &Document, ids: &[NodeId]) -> bool {
let paths = d.index_paths(ids.iter().copied());
ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).and_then(|n| n.geometric_bounds()).is_none_or(rect_in_range))
if ids.is_empty() {
return true;
}
if d.has_lookup_cache() || ids.len() <= 16 {
return ids.iter().all(|id| d.node(*id).and_then(|n| n.geometric_bounds()).is_none_or(rect_in_range));
}
let want: std::collections::HashSet<NodeId> = ids.iter().copied().collect();
let mut ok = true;
d.walk(|n| {
if !ok {
return;
}
if want.contains(&n.id)
&& let Some(b) = n.geometric_bounds()
&& !rect_in_range(b)
{
ok = false;
}
});
ok
}