diff --git a/crates/engine/src/cmd/joints_tests.rs b/crates/engine/src/cmd/joints_tests.rs index 7a772adae..68c1b7fee 100644 --- a/crates/engine/src/cmd/joints_tests.rs +++ b/crates/engine/src/cmd/joints_tests.rs @@ -1287,6 +1287,87 @@ fn hidden_joints_still_drive_and_are_saved_with_the_design() { let _ = std::fs::remove_dir_all(&dir); } +/// #3892: a large nested STEP assembly hides thousands of joints, and the browser asks about +/// every joint of the design on every frame: the answer must not walk the hidden-joint list, +/// so the work must not grow with the number of hidden joints. The hidden joint stays hidden, +/// the shown one stays shown, and undo and redo keep the hiding right. +#[test] +fn hidden_joint_lookups_do_not_walk_the_hidden_joint_list() { + use crate::occurrences::visibility_work; + + let mut s = hinged(); + let (hinge, glue) = (joint(&s, "Hinge"), joint(&s, "Glue")); + + // The hidden joints of an imported assembly: thousands of ids (#3892). + let hide_many = |s: &mut Session, n: u64| { + s.visibility.hidden_joints.clear(); + for id in 0..n { + s.visibility.hidden_joints.push(id); + } + }; + // The entries one lookup walked, for a joint that is not hidden. + let walked_by = |s: &Session, id: u64| { + visibility_work::take(); + let visible = s.joint_visible(id); + let walked = visibility_work::take(); + assert!(visible, "joint {id} is not hidden here"); + walked + }; + + hide_many(&mut s, 10); + let few = walked_by(&s, 9_000_001); + hide_many(&mut s, 10_000); + let many = walked_by(&s, 9_000_001); + assert!( + many <= few + 4, + "a joint lookup walked {many} entries of a 10,000-entry hidden-joint list and {few} of a \ + 10-entry one: the work must not grow with the number of hidden joints" + ); + + // The behaviour is unchanged: the hidden joint is hidden, the shown one is shown, and undo + // and redo keep the hiding right. + s.visibility.hidden_joints.clear(); + run(&mut s, "browser.visibility", json!({"joints": ["Hinge"], "visible": false})); + assert!(!s.joint_visible(hinge) && s.joint_visible(glue)); + run(&mut s, "edit.undo", json!({})); + assert!(s.joint_visible(hinge), "undo shows the hinge again"); + run(&mut s, "edit.redo", json!({})); + assert!(!s.joint_visible(hinge), "redo hides it again"); +} + +/// The cost of a frame's worth of joint questions, with few and with many hidden joints: the +/// manual measurement behind #3892. Run it with `--ignored --nocapture`. +#[test] +#[ignore = "manual scaling measurement"] +fn joint_visibility_lookup_cost_by_hidden_joint_count() { + use crate::occurrences::visibility_work; + + let joints = 1_000u64; + for hidden in [0u64, 10, 100, 1_000, 10_000] { + let mut s = Session::default(); + for id in 0..hidden { + s.visibility.hidden_joints.push(id); + } + let mut times = Vec::new(); + for _ in 0..11 { + let start = std::time::Instant::now(); + for id in 0..joints { + let _ = s.joint_visible(id + hidden + 1); + } + times.push(start.elapsed().as_secs_f64() * 1e3); + } + times.sort_by(f64::total_cmp); + // The index is built once per change of the view, apart from the answers themselves. + println!( + "hidden_joints={hidden:>6} questions={joints} median_ms={:.3} min_ms={:.3} max_ms={:.3} built_entries={}", + times[times.len() / 2], + times[0], + times[times.len() - 1], + visibility_work::built_take() + ); + } +} + /// #1160: a design saved before joints could be hidden (format 19, no `hidden_joints`) opens /// with every joint shown; and a new joint that takes a deleted hidden joint's id starts shown. #[test] diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index a860dd7ed..64ef16a91 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -474,6 +474,10 @@ pub struct Session { /// (see [`Session::solve_joints`]). joints_settled: Option<(Arc, std::sync::Weak)>, occurrence_visibility_cache: std::sync::Mutex>, + /// The hidden joints and folders of the view, as sets: the browser asks about every joint + /// of the design on every frame (#3892), and an answer that walked the hidden lists made a + /// frame cost grow with the size of the design. + visibility_index_cache: std::sync::Mutex>, removed_later_cache: std::sync::Mutex>, occurrence_bodies_cache: std::sync::Mutex>, placement_index_cache: std::sync::Mutex>, @@ -679,6 +683,7 @@ impl Session { world_cache: Default::default(), joints_settled: None, occurrence_visibility_cache: Default::default(), + visibility_index_cache: Default::default(), removed_later_cache: Default::default(), occurrence_bodies_cache: Default::default(), placement_index_cache: Default::default(), @@ -1548,6 +1553,7 @@ impl Session { world_cache: std::sync::Mutex::new(self.world_cache.lock().ok().and_then(|cache| cache.clone())), joints_settled: self.joints_settled.clone(), occurrence_visibility_cache: Default::default(), + visibility_index_cache: Default::default(), removed_later_cache: Default::default(), occurrence_bodies_cache: Default::default(), placement_index_cache: Default::default(), diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rs index 4ec5faed2..a5cfae493 100644 --- a/crates/engine/src/occurrences.rs +++ b/crates/engine/src/occurrences.rs @@ -1,5 +1,5 @@ //! Exact placement identity and session view/authoring state. -use crate::{EngineError, Result, Sel, Session}; +use crate::{EngineError, Result, Sel, Session, Visibility}; use solidcraft_doc::{FeatureKind, IDENTITY, Mat, PlaneRef, mat_mul}; #[derive(Clone, Debug)] @@ -32,6 +32,139 @@ pub(crate) struct VisibilityCache { bodies: std::collections::BTreeSet, } +/// The hidden joints and folders of the view, as sets: the browser asks about every joint +/// and every folder of the design on every frame, and an answer that walked the hidden +/// lists made a frame cost grow with the size of the design (#3892). The sets are built +/// when the view changes and are kept until it changes again. +pub(crate) struct VisibilityIndex { + /// The revision of the design the sets were built for. + revision: u64, + /// Where the hidden joints were when the sets were built: the list is replaced (the + /// whole view is replaced) or written in place (a joint is hidden or shown), and this + /// says whether the list the sets were built from is still the list of the view. + joints_at: ListId, + /// The hidden joint ids. + joint_ids: std::collections::HashSet, + /// Where the hidden folders were when the sets were built. + folders_at: ListId, + /// The hidden folder keys. + folder_keys: std::collections::HashSet, + /// The hidden joints and folders, as they were when the sets were built: they are + /// compared with these to tell a change of the view from a change of the design alone + /// (the design changes far more often than the view does). + joints: Vec, + folders: Vec, +} + +/// Where a list of hidden items was: the address of its buffer and how many items it held. +/// A list that is replaced gets a buffer of its own (the old one is still alive while the +/// new one is allocated, so the addresses differ), and a list that is written in place keeps +/// its buffer; the length then says how much of it is written. +#[derive(Clone, Copy, PartialEq, Eq)] +struct ListId { + address: usize, + length: usize, +} + +impl ListId { + fn of(list: &[T]) -> ListId { + ListId { address: list.as_ptr() as usize, length: list.len() } + } +} + +impl VisibilityIndex { + /// The sets of the hidden joints and folders of a view. + fn new(revision: u64, v: &Visibility) -> VisibilityIndex { + let joint_ids: std::collections::HashSet = v.hidden_joints.iter().copied().collect(); + let folder_keys: std::collections::HashSet = v.hidden_folders.iter().cloned().collect(); + visibility_work::built(joint_ids.len() as u64 + folder_keys.len() as u64); + VisibilityIndex { + revision, + joints_at: ListId::of(&v.hidden_joints), + joint_ids, + folders_at: ListId::of(&v.hidden_folders), + folder_keys, + joints: v.hidden_joints.clone(), + folders: v.hidden_folders.clone(), + } + } + + /// Do the sets still answer for this design and this view? The revision says the design + /// changed; the lists say the view changed under it (the view is replaced outside the + /// engine too, without a revision of its own). + /// + /// The first and last entries of each list are part of the answer: a buffer that was freed + /// and handed out again holds another list, and the entries say so. + fn matches(&self, revision: u64, v: &Visibility) -> bool { + self.revision == revision + && self.joints_at == ListId::of(&v.hidden_joints) + && self.folders_at == ListId::of(&v.hidden_folders) + && self.joints.first() == v.hidden_joints.first() + && self.joints.last() == v.hidden_joints.last() + && self.folders.first() == v.hidden_folders.first() + && self.folders.last() == v.hidden_folders.last() + } + + /// Are the hidden joints and folders the ones the sets were built from? A design that + /// changed without touching the view leaves the sets alone. + fn same_lists(&self, v: &Visibility) -> bool { + self.joints == v.hidden_joints && self.folders == v.hidden_folders + } + + /// The lists are the ones the sets were built from, at another revision. + fn restamp(&mut self, revision: u64, v: &Visibility) { + self.revision = revision; + self.joints_at = ListId::of(&v.hidden_joints); + self.folders_at = ListId::of(&v.hidden_folders); + } +} + +/// How many entries of the hidden lists a visibility answer had to walk, and how many the +/// index was built from. The browser asks about every joint of the design on every frame, so +/// the answer must not cost more as the design grows (#3892); the counters make that cost +/// visible to a test. +pub(crate) mod visibility_work { + #[cfg(test)] + use std::cell::Cell; + + // The counter of the thread that asks: the tests run beside each other, and each counts + // its own work. + #[cfg(test)] + thread_local! { + static WALKED: Cell = const { Cell::new(0) }; + static BUILT: Cell = const { Cell::new(0) }; + } + + /// The entries the answers of this thread walked since the last [`take`]. + #[cfg(test)] + pub(crate) fn take() -> u64 { + WALKED.with(|walked| walked.replace(0)) + } + + /// Count the entries an answer walked. + pub(crate) fn add(walked: u64) { + #[cfg(test)] + WALKED.with(|count| count.set(count.get() + walked)); + #[cfg(not(test))] + let _ = walked; + } + + /// Count the entries the index was built from: the index is built once per change of the + /// view, not once per answer, so this work is apart from the answers' own. + pub(crate) fn built(built: u64) { + #[cfg(test)] + BUILT.with(|count| count.set(count.get() + built)); + #[cfg(not(test))] + let _ = built; + } + + /// The entries the index was built from since the last [`built_take`]. + #[cfg(test)] + pub(crate) fn built_take() -> u64 { + BUILT.with(|count| count.replace(0)) + } +} + /// [`Session::occurrence_bodies`] answers for one document, evaluated model and set of pending /// moves. The document and model are kept alive with the answers, so neither a new document nor /// a later allocation at the same address can reuse them. @@ -562,10 +695,36 @@ impl Session { Ok(count) } + /// The hidden joints and folders of the view, as sets: the browser asks about every joint + /// of the design on every frame, and an answer that walked the hidden lists made a frame + /// cost grow with the size of the design (#3892). The sets are built when the view changes + /// and are kept until it changes again. + fn visibility_index(&self) -> Option>> { + let mut cache = self.visibility_index_cache.lock().ok()?; + let v = &self.visibility; + if cache.as_ref().is_none_or(|c| !c.matches(self.revision, v)) { + // The design or the view changed. The sets are rebuilt only when the hidden lists + // themselves changed: a change of the design alone leaves them alone. + if cache.as_ref().is_some_and(|c| c.same_lists(v)) { + if let Some(c) = cache.as_mut() { + c.restamp(self.revision, v); + } + } else { + *cache = Some(VisibilityIndex::new(self.revision, v)); + } + } + Some(cache) + } + /// Whether a joint's glyph is drawn (`browser.visibility`). Hiding a joint only hides its /// drawing: it still constrains and drives the parts. /// Is the joint shown itself (its own eye; the Joints folder may still hide it)? pub fn joint_visible(&self, id: u64) -> bool { + if let Some(cache) = self.visibility_index() { + return cache.as_ref().is_none_or(|c| !c.joint_ids.contains(&id)); + } + // The lock is poisoned: answer from the list itself. + visibility_work::add(self.visibility.hidden_joints.len() as u64); !self.visibility.hidden_joints.contains(&id) } @@ -582,6 +741,11 @@ impl Session { /// Is a browser folder or group hidden itself (by tree key, see `Visibility::hidden_folders`)? pub fn folder_hidden(&self, key: &str) -> bool { + if let Some(cache) = self.visibility_index() { + return cache.as_ref().is_none_or(|c| c.folder_keys.contains(key)); + } + // The lock is poisoned: answer from the list itself. + visibility_work::add(self.visibility.hidden_folders.len() as u64); self.visibility.hidden_folders.iter().any(|k| k == key) }