* 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:
1 parent
d1398e2c52
commit
ebdc0bc07e
4 files changed
+300
-12
No files matched your search
@@ -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);
|
||||
}
|
||||
@@ -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(),
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user