diff --git a/crates/engine/src/cmd/occurrence_tests.rs b/crates/engine/src/cmd/occurrence_tests.rs index 5b3c2df45..94d6bd928 100644 --- a/crates/engine/src/cmd/occurrence_tests.rs +++ b/crates/engine/src/cmd/occurrence_tests.rs @@ -1383,3 +1383,67 @@ fn a_body_seen_in_another_placement_copies_from_there() { let state = s.model.state(); assert_eq!(s.doc.model_body_component(state.body("Cube (2)").unwrap()), 0); } + +/// A nested assembly's body listing, and the indexed placement agreeing with the plain walk +/// (#7502: listing a subtree must cost the subtree, not the subtree times the design). +#[test] +fn occurrence_bodies_lists_a_nested_assembly() { + let mut s = Session::default(); + let (_outer, outer) = created(&mut s, "Outer"); + run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Shell"})); + let (_middle, middle) = created(&mut s, "Middle"); + run(&mut s, "solid.box", json!({"length": 2, "width": 2, "height": 2, "body_name": "Plate"})); + let (_inner, inner) = created(&mut s, "Inner"); + run(&mut s, "solid.box", json!({"length": 1, "width": 1, "height": 1, "body_name": "Pin"})); + let deep = [outer, middle, inner]; + let sorted = |v: Vec| { + let mut v = v; + v.sort(); + v + }; + assert_eq!(sorted(s.occurrence_bodies(&deep, true).unwrap()), ["Pin"]); + assert_eq!(sorted(s.occurrence_bodies(&[outer, middle], true).unwrap()), ["Pin", "Plate"]); + assert_eq!(sorted(s.occurrence_bodies(&[outer], true).unwrap()), ["Pin", "Plate", "Shell"]); + assert_eq!(sorted(s.occurrence_bodies(&[outer, middle], false).unwrap()), ["Plate"]); + // The indexed placement answers exactly what the plain walk does. + for path in [&deep[..], &[outer, middle][..], &[outer][..]] { + let (indexed, walked) = (s.occurrence_placement(path).unwrap(), s.occurrence_placement_walk(path).unwrap()); + assert_eq!(indexed.component, walked.component); + assert_eq!(indexed.name, walked.name); + assert_eq!(indexed.world, walked.world); + assert_eq!(indexed.bodies.len(), walked.bodies.len()); + for (a, b) in indexed.bodies.iter().zip(&walked.bodies) { + assert_eq!((a.source.as_str(), a.world.as_str()), (b.source.as_str(), b.world.as_str())); + } + } +} + +/// A burst of other paths retires single remembered answers instead of clearing the whole +/// cache, so the active occurrence's listing survives and needn't re-expand (#7502). +#[test] +fn occurrence_bodies_cache_retires_one_answer_when_full() { + let mut s = Session::default(); + let (_assembly, assembly) = created(&mut s, "Assembly"); + let (part, _) = created(&mut s, "Part"); + run(&mut s, "solid.box", json!({"length": 1, "width": 1, "height": 1, "body_name": "Part"})); + let mut copies = Vec::new(); + for i in 0..130 { + let o = run(&mut s, "occurrence.copy", json!({"component": part, "translate": [i as f64 * 10.0, 0.0, 0.0]}))["occurrence"].as_u64().unwrap(); + copies.push(o); + } + // The active listing (the whole assembly) is asked first and remembered. + let root = vec![assembly]; + assert_eq!(s.occurrence_bodies(&root, true).unwrap().len(), 131); + // Then a burst of per-copy queries: 260 more keys, over the cache's 256-entry limit. + for o in &copies { + let path = vec![assembly, *o]; + assert_eq!(s.occurrence_bodies(&path, false).unwrap().len(), 1); + assert_eq!(s.occurrence_bodies(&path, true).unwrap().len(), 1); + } + let guard = s.occurrence_bodies_cache.lock().unwrap(); + let cache = guard.as_ref().unwrap(); + assert!(cache.bodies.contains_key(&(root.clone(), true)), "the active listing survives a burst of other paths"); + assert!(cache.bodies.len() <= 256, "the cache stays bounded at its limit"); + drop(guard); + assert_eq!(s.occurrence_bodies(&root, true).unwrap().len(), 131); +} diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 85600713b..4f7207088 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -386,6 +386,7 @@ pub struct Session { occurrence_visibility_cache: std::sync::Mutex>, removed_later_cache: std::sync::Mutex>, occurrence_bodies_cache: std::sync::Mutex>, + placement_index_cache: std::sync::Mutex>, /// Pairs `inspect.clearance` measured, by the bodies' geometry where they stood (shared with /// scratch copies): a body that did not change or move is not measured again. clearance_cache: std::sync::Arc>, @@ -575,6 +576,7 @@ impl Session { occurrence_visibility_cache: Default::default(), removed_later_cache: Default::default(), occurrence_bodies_cache: Default::default(), + placement_index_cache: Default::default(), clearance_cache: Default::default(), body_renames: Vec::new(), contact_meshes: Default::default(), @@ -721,6 +723,12 @@ impl Session { /// Mutable document (copy-on-write). pub fn doc_mut(&mut self) -> &mut Document { + // The placement index keeps the document alive with its answers; let it go before an + // in-place edit, so the edit stays in place (a shared handle would clone the document + // to a new address behind the crash journal's back, #7502) and no stale lookup outlives it. + if let Ok(mut index) = self.placement_index_cache.lock() { + *index = None; + } Arc::make_mut(&mut self.doc) } @@ -1106,6 +1114,9 @@ impl Session { } // Checked first: storing makes the document unique (a copy when the undo step shares it). if self.model.edited_sketches(&self.doc).next().is_some() { + if let Ok(mut index) = self.placement_index_cache.lock() { + *index = None; + } self.model.adopt_solved_sketches(Arc::make_mut(&mut self.doc)); } Ok(()) @@ -1357,6 +1368,7 @@ impl Session { occurrence_visibility_cache: Default::default(), removed_later_cache: Default::default(), occurrence_bodies_cache: Default::default(), + placement_index_cache: Default::default(), clearance_cache: self.clearance_cache.clone(), body_renames: self.body_renames.clone(), contact_meshes: self.contact_meshes.clone(), diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rs index a07b4a305..e63504777 100644 --- a/crates/engine/src/occurrences.rs +++ b/crates/engine/src/occurrences.rs @@ -39,12 +39,84 @@ pub(crate) struct OccurrenceBodiesCache { doc: std::sync::Arc, model: std::sync::Arc, pending_moves: std::collections::BTreeMap, - bodies: std::collections::HashMap<(Vec, bool), std::sync::Arc<[String]>>, + pub(crate) bodies: std::collections::HashMap<(Vec, bool), std::sync::Arc<[String]>>, } -/// How many placements' answers [`OccurrenceBodiesCache`] keeps before it starts again. +/// How many placements' answers [`OccurrenceBodiesCache`] keeps before retiring one for each +/// new one. const OCCURRENCE_BODIES_CACHED: usize = 256; +/// Placement identity for one document and evaluated model, worked out once per design: +/// occurrences by (parent, id), children per parent, bodies per component, and each placement +/// path already named. Listing a subtree then costs the subtree, not the subtree times the +/// design (#7502). Pending moves change a placement's matrices but never its component or its +/// bodies' names, so the index is keyed on the document and model alone. +pub(crate) struct PlacementIndex { + doc: std::sync::Arc, + state: std::sync::Arc, + /// The index into `doc.occurrences` of each (parent component, occurrence id). + by_parent_id: std::collections::HashMap<(u64, u64), usize>, + /// The occurrence ids of each parent component's children, in document order. + children: std::collections::HashMap>, + /// The source body names of each component. + bodies: std::collections::HashMap>, + /// The ids of the design's components. + components: std::collections::HashSet, + /// Each placement path already named: its bodies' world names. + placed: std::collections::HashMap, std::sync::Arc<[OccurrenceBody]>>, +} + +/// How many placement paths [`PlacementIndex`] names before it stops remembering more. +const PLACEMENT_PATHS_CACHED: usize = solidcraft_doc::MAX_PLACEMENTS; + +impl PlacementIndex { + fn new(doc: &std::sync::Arc, state: &std::sync::Arc) -> PlacementIndex { + let mut by_parent_id = std::collections::HashMap::with_capacity(doc.occurrences.len()); + let mut children: std::collections::HashMap> = std::collections::HashMap::new(); + for (i, o) in doc.occurrences.iter().enumerate() { + by_parent_id.insert((o.parent, o.id), i); + children.entry(o.parent).or_default().push(o.id); + } + let mut bodies: std::collections::HashMap> = std::collections::HashMap::new(); + for b in &state.bodies { + bodies.entry(doc.model_body_component(b)).or_default().push(b.name.clone()); + } + PlacementIndex { + doc: doc.clone(), + state: state.clone(), + by_parent_id, + children, + bodies, + components: doc.components.iter().map(|c| c.id).collect(), + placed: std::collections::HashMap::new(), + } + } + + fn matches(&self, session: &Session, model: &std::sync::Arc) -> bool { + std::sync::Arc::ptr_eq(&self.doc, &session.doc) && std::sync::Arc::ptr_eq(&self.state, model) + } + + /// The component's bodies named at `path`, remembered until the index is replaced. + fn bodies_at(&mut self, path: &[u64], component: u64) -> std::sync::Arc<[OccurrenceBody]> { + if let Some(bodies) = self.placed.get(path) { + return bodies.clone(); + } + let names = solidcraft_doc::WorldNames::new(&self.doc, &self.state); + let empty = Vec::new(); + let bodies: std::sync::Arc<[OccurrenceBody]> = self + .bodies + .get(&component) + .unwrap_or(&empty) + .iter() + .map(|source| OccurrenceBody { source: source.clone(), world: names.name(source, component, path) }) + .collect(); + if self.placed.len() < PLACEMENT_PATHS_CACHED { + self.placed.insert(path.to_vec(), bodies.clone()); + } + bodies + } +} + impl OccurrenceBodiesCache { fn matches(&self, session: &Session, model: &std::sync::Arc) -> bool { std::sync::Arc::ptr_eq(&self.doc, &session.doc) && std::sync::Arc::ptr_eq(&self.model, model) && self.pending_moves == session.pending_moves @@ -139,8 +211,72 @@ impl Session { } std::borrow::Cow::Owned(doc) } - /// Resolve only the supplied path, never an exponentially expanded assembly. + /// Resolve only the supplied path, never an exponentially expanded assembly. The placement + /// index answers from lookups; the plain walk stays as the fallback and the error reporter. pub fn occurrence_placement(&self, path: &[u64]) -> Result { + if path.is_empty() || path.len() > 64 { + return Err(invalid("occurrence path must contain 1..64 ids")); + } + if let Some(placement) = self.occurrence_placement_indexed(path) { + return Ok(placement); + } + self.occurrence_placement_walk(path) + } + + /// [`Self::occurrence_placement`] through [`PlacementIndex`]: the path walk multiplies + /// transforms as the plain walk does, but occurrences, components and body names are + /// lookups. `None` for any path the index can't answer, so the walk reports the exact error. + fn occurrence_placement_indexed(&self, path: &[u64]) -> Option { + let mut guard = self.placement_index()?; + let index = guard.as_mut()?; + let mut component = 0; + let mut world = IDENTITY; + let mut parent_world = IDENTITY; + let mut leaf = None; + for id in path { + let i = *index.by_parent_id.get(&(component, *id))?; + let o = &index.doc.occurrences[i]; + if !index.components.contains(&o.component) { + return None; + } + parent_world = world; + world = mat_mul(&world, self.pending_moves.get(id).unwrap_or(&o.transform)); + if world.iter().flatten().any(|x| !x.is_finite()) { + return None; + } + leaf = Some(i); + component = o.component; + } + let leaf = leaf?; + let bodies = index.bodies_at(path, component).to_vec(); + let leaf = &index.doc.occurrences[leaf]; + Some(OccurrencePlacement { + occurrence: leaf.id, + component, + path: path.to_vec(), + name: leaf.name.clone(), + world, + local: self.pending_moves.get(&leaf.id).copied().unwrap_or(leaf.transform), + parent_world, + grounded: leaf.grounded, + bodies, + }) + } + + /// The placement index for the current document and model, built on first use. + fn placement_index(&self) -> Option>> { + let model = self.model.state(); + let mut guard = self.placement_index_cache.lock().ok()?; + let index = guard.get_or_insert_with(|| PlacementIndex::new(&self.doc, &model)); + if !index.matches(self, &model) { + *index = PlacementIndex::new(&self.doc, &model); + } + Some(guard) + } + + /// The plain walk over `doc.occurrences`, kept as the fallback for paths the index can't + /// answer and as the reference the indexed answers are checked against (#7502). + pub(crate) fn occurrence_placement_walk(&self, path: &[u64]) -> Result { if path.is_empty() || path.len() > 64 { return Err(invalid("occurrence path must contain 1..64 ids")); } @@ -223,7 +359,7 @@ impl Session { } let bodies: std::sync::Arc<[String]> = self.expand_occurrence_bodies(path, descendants)?.into(); if let Ok(mut cache) = self.occurrence_bodies_cache.lock() { - if cache.as_ref().is_none_or(|c| !c.matches(self, &model) || c.bodies.len() >= OCCURRENCE_BODIES_CACHED) { + if cache.as_ref().is_none_or(|c| !c.matches(self, &model)) { *cache = Some(OccurrenceBodiesCache { doc: self.doc.clone(), model, @@ -232,6 +368,15 @@ impl Session { }); } if let Some(cache) = cache.as_mut() { + if !cache.bodies.contains_key(&key) && cache.bodies.len() >= OCCURRENCE_BODIES_CACHED { + // Retire one remembered answer, not the whole cache: a burst of other + // paths (a Browser reveal, a hover) no longer evicts the active + // occurrence's entry and forces a full re-expansion on the next + // highlight build (#7502). + if let Some(evict) = cache.bodies.keys().next().cloned() { + cache.bodies.remove(&evict); + } + } cache.bodies.insert(key, bodies.clone()); } } @@ -239,6 +384,9 @@ impl Session { } fn expand_occurrence_bodies(&self, path: &[u64], descendants: bool) -> Result> { + if let Some(out) = self.expand_occurrence_bodies_indexed(path, descendants) { + return Ok(out); + } let mut stack = vec![self.occurrence_placement(path)?]; let mut out = Vec::new(); let mut count = 0; @@ -255,6 +403,63 @@ impl Session { Ok(out) } + /// [`Self::expand_occurrence_bodies`] through [`PlacementIndex`]: children and bodies are + /// lookups and each path is named once, so a listing costs the subtree's size, not the + /// subtree times the design (#7502). `None` when the index can't answer (a lock miss, an + /// invalid path, a cycle or a design over the limits), so the walk reports the exact error. + fn expand_occurrence_bodies_indexed(&self, path: &[u64], descendants: bool) -> Option> { + if path.is_empty() { + return None; + } + let mut guard = self.placement_index()?; + let index = guard.as_mut()?; + let mut component = 0; + let mut world = IDENTITY; + for id in path { + let i = *index.by_parent_id.get(&(component, *id))?; + let o = &index.doc.occurrences[i]; + if !index.components.contains(&o.component) { + return None; + } + world = mat_mul(&world, self.pending_moves.get(id).unwrap_or(&o.transform)); + if world.iter().flatten().any(|x| !x.is_finite()) { + return None; + } + component = o.component; + } + let mut stack = vec![(path.to_vec(), component, world)]; + let mut out = Vec::new(); + let mut count = 0; + while let Some((path, component, world)) = stack.pop() { + count += 1; + let bodies = index.bodies_at(&path, component); + if count > 100_000 || out.len() + bodies.len() > 100_000 { + return None; + } + out.extend(bodies.iter().map(|b| b.world.clone())); + if descendants && path.len() < 64 { + for child in index.children.get(&component).into_iter().flatten() { + if path.contains(child) { + return None; + } + let i = *index.by_parent_id.get(&(component, *child))?; + let o = &index.doc.occurrences[i]; + if !index.components.contains(&o.component) { + return None; + } + let child_world = mat_mul(&world, self.pending_moves.get(child).unwrap_or(&o.transform)); + if child_world.iter().flatten().any(|x| !x.is_finite()) { + return None; + } + let mut next = path.clone(); + next.push(*child); + stack.push((next, o.component, child_world)); + } + } + } + Some(out) + } + /// The world names of the bodies `features` made (#5099), in every placement of their /// component, or only in `placement` (a component and the path of one of its placements). pub fn feature_bodies(&self, features: &[u64], placement: Option<(u64, &[u64])>) -> Vec { diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs index f2fb8de10..a8720eb4a 100644 --- a/crates/ui-egui/src/browser.rs +++ b/crates/ui-egui/src/browser.rs @@ -731,9 +731,13 @@ pub(crate) fn reveal_pick(app: &mut SolveApp) { } } -/// Whether the body being revealed is in this placement or one below it: it opens. -fn reveals_in_occurrence(app: &SolveApp, path: &[u64]) -> bool { - app.tree.reveal.as_ref().is_some_and(|r| app.session.occurrence_bodies(path, true).is_ok_and(|bodies| bodies.contains(r))) +/// The placement path of the body being revealed, resolved once per model: a row opens when +/// the body's path runs through it, instead of every row expanding its subtree to test +/// containment (#7502). `None` when nothing is revealed or the body is a top-level design body. +fn reveal_path(app: &mut SolveApp) -> Option> { + let body = app.tree.reveal.clone()?; + prepare_model(app); + app.tree.model.as_mut()?.body_path(&app.session, &body) } pub(crate) fn is_open(app: &SolveApp, key: &str, default: bool) -> bool { @@ -1358,10 +1362,13 @@ fn component_rows_inner( root: &mut cache::Node, ) { let key = &root.key; - if let Some(body) = app.tree.reveal.as_ref() - && (cache.root_bodies.contains(body) || root.children.iter().any(|path| reveals_in_occurrence(app, path))) - { - app.tree.collapsed.remove(key); + let reveal = app.tree.reveal.clone(); + if let Some(body) = reveal.as_ref() { + let reveals = + cache.root_bodies.contains(body) || reveal_path(app).is_some_and(|rp| root.children.iter().any(|path| rp.starts_with(path.as_slice()))); + if reveals { + app.tree.collapsed.remove(key); + } } let open = is_open(app, key, true); let active = app.session.active_component == id; @@ -1497,7 +1504,7 @@ fn occurrence_rows_inner( placement: &mut cache::Node, ) { let key = &placement.key; - if reveals_in_occurrence(app, path) { + if reveal_path(app).is_some_and(|rp| rp.starts_with(path)) { app.tree.collapsed.remove(key); } let open = is_open(app, key, true);