Assembly: deeply nested body selection no longer stalls the window (#7502) (#7694)

* claim: #7502

* Assembly: name placed bodies from a per-design index, reveal the Browser from the body's path, evict cache entries singly (#7502)

* Release the placement index before in-place document edits so pinning body names stays in place

---------

Co-authored-by: Dahak Builds <dahakbuilds@users.noreply.github.com>
This commit is contained in:
Dahak BuildsandDahak Builds authored and GitHub committed 2026-10-27 19:44:52 +00:00
1 parent d1398e2c52
commit ebdc0bc07e
4 files changed
+300 -12

No files matched your search

+64
View File
@@ -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<String>| {
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);
}
+12
View File
@@ -386,6 +386,7 @@ pub struct Session {
occurrence_visibility_cache: std::sync::Mutex<Option<occurrences::VisibilityCache>>,
removed_later_cache: std::sync::Mutex<Option<occurrences::RemovedLaterCache>>,
occurrence_bodies_cache: std::sync::Mutex<Option<occurrences::OccurrenceBodiesCache>>,
placement_index_cache: std::sync::Mutex<Option<occurrences::PlacementIndex>>,
/// 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<std::sync::Mutex<cmd::clearance::PairCache>>,
@@ -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(),
+209 -4
View File
@@ -39,12 +39,84 @@ pub(crate) struct OccurrenceBodiesCache {
doc: std::sync::Arc<solidcraft_doc::Document>,
model: std::sync::Arc<solidcraft_doc::ModelState>,
pending_moves: std::collections::BTreeMap<u64, Mat>,
bodies: std::collections::HashMap<(Vec<u64>, bool), std::sync::Arc<[String]>>,
pub(crate) bodies: std::collections::HashMap<(Vec<u64>, 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<solidcraft_doc::Document>,
state: std::sync::Arc<solidcraft_doc::ModelState>,
/// 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<u64, Vec<u64>>,
/// The source body names of each component.
bodies: std::collections::HashMap<u64, Vec<String>>,
/// The ids of the design's components.
components: std::collections::HashSet<u64>,
/// Each placement path already named: its bodies' world names.
placed: std::collections::HashMap<Vec<u64>, 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<solidcraft_doc::Document>, state: &std::sync::Arc<solidcraft_doc::ModelState>) -> PlacementIndex {
let mut by_parent_id = std::collections::HashMap::with_capacity(doc.occurrences.len());
let mut children: std::collections::HashMap<u64, Vec<u64>> = 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<u64, Vec<String>> = 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<solidcraft_doc::ModelState>) -> 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<solidcraft_doc::ModelState>) -> 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<OccurrencePlacement> {
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<OccurrencePlacement> {
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<std::sync::MutexGuard<'_, Option<PlacementIndex>>> {
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<OccurrencePlacement> {
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<Vec<String>> {
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<Vec<String>> {
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<String> {
+15 -8
View File
@@ -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<Vec<u64>> {
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);