Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Engine: lower the per-command cost of evaluating large designs (#9615)

kaltenbrunnermarkus5b6e5815a3af
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index 62927a487f..321fa3a5a7 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -1194,13 +1194,21 @@ impl ModelState {
/// to the budget keep only its last few states, so setting a parameter back recomputed what
/// had dropped out.
fn added_bytes(&self, before: &ModelState) -> usize {
+ // `before`'s bodies by solid, and its sketches by address: looked up per body and sketch,
+ // not searched (every feature's result is charged, so searching was bodies² per feature).
+ // Bodies sharing a solid are still told apart by `same_shape` (the mesh as well).
+ let mut solids: std::collections::HashMap<usize, Vec<&Body>> = std::collections::HashMap::with_capacity(before.bodies.len());
+ for o in &before.bodies {
+ solids.entry(o.body.solid_id()).or_default().push(&o.body);
+ }
let bodies: usize = self
.bodies
.iter()
- .filter(|b| !before.bodies.iter().any(|o| o.body.same_shape(&b.body)))
+ .filter(|b| !solids.get(&b.body.solid_id()).is_some_and(|os| os.iter().any(|o| o.same_shape(&b.body))))
.map(|b| if b.bytes > 0 { b.bytes } else { b.body.retained_bytes() })
.sum();
- let sketches: usize = self.sketches.iter().filter(|s| !before.sketches.iter().any(|o| Arc::ptr_eq(o, s))).map(|s| s.retained_bytes()).sum();
+ let kept: std::collections::HashSet<*const SolvedSketch> = before.sketches.iter().map(Arc::as_ptr).collect();
+ let sketches: usize = self.sketches.iter().filter(|s| !kept.contains(&Arc::as_ptr(s))).map(|s| s.retained_bytes()).sum();
bodies + sketches + self.sheets.len() * 4096 + self.threads.len() * 192 + self.construct.len() * 192
}
@@ -1299,6 +1307,10 @@ pub struct Model {
kept: KeptSlot,
/// The imported texts' digests the last `evaluate` fingerprinted the features with.
step_digests: StepDigests,
+ /// The address of the shared document whose fingerprints the results were last given in
+ /// full, with [`fingerprints_digest`] of them then ([`Model::pinned_prefix`]). Only an
+ /// address: a reference to the document would make every in-place edit of it a copy.
+ fingerprinted: Option<(usize, u64)>,
/// The document context the last `evaluate` ran in ([`context_digest`]).
context: u64,
/// The last active result of each feature hidden by the history marker, with its document
@@ -1418,32 +1430,40 @@ fn quantize(sk: &mut solidcraft_sketch::Sketch) {
/// file's text by its digest.
/// Hash [`feature_json`] of `f` into `h`. Every evaluation fingerprints every feature, and in a
/// design built command by command almost all of them are the same as last time: the text of a
-/// feature is kept (per thread, by id) with the feature it was written from, and written again
-/// only when the feature differs. An Import's text also depends on its STEP digest, so it is
-/// written each time as before.
+/// feature is kept (by id) with the feature it was written from, and written again only when the
+/// feature differs. An Import's text also depends on its STEP digest, so it is written each time
+/// as before.
+///
+/// The texts are shared by every thread: a command evaluated ahead runs on a new worker thread
+/// each time (the desktop's deferred commands and delete checks, the control channel's ahead
+/// jobs), and a per-thread store started empty there, so every ahead run wrote out every
+/// feature again. The lock is held only to look up or store an entry, never while a feature is
+/// compared or written; an entry is the same whichever thread wrote it, since the text is a
+/// function of the feature alone.
fn hash_feature_json(f: &Feature, steps: &StepDigests, h: &mut impl Hasher) {
+ type Written = std::collections::HashMap<u64, Arc<(Feature, String)>>;
+ static WRITTEN: std::sync::LazyLock<std::sync::Mutex<Written>> = std::sync::LazyLock::new(Default::default);
if matches!(f.kind, FeatureKind::Import { .. }) {
feature_json(f, steps).hash(h);
return;
}
- thread_local! {
- static WRITTEN: std::cell::RefCell<std::collections::HashMap<u64, (Feature, String)>> = std::cell::RefCell::new(std::collections::HashMap::new());
+ let seen = WRITTEN.lock().unwrap_or_else(|e| e.into_inner()).get(&f.id).cloned();
+ if let Some(seen) = seen
+ && seen.0 == *f
+ {
+ seen.1.hash(h);
+ return;
}
- WRITTEN.with(|written| {
- let mut written = written.borrow_mut();
- if let Some((seen, json)) = written.get(&f.id)
- && seen == f
- {
- json.hash(h);
- return;
- }
- let json = feature_json(f, steps);
- json.hash(h);
- if written.len() >= 1 << 15 {
- written.clear();
- }
- written.insert(f.id, (f.clone(), json));
- });
+ #[cfg(test)]
+ cost_tests::count_written();
+ let json = feature_json(f, steps);
+ json.hash(h);
+ let entry = Arc::new((f.clone(), json));
+ let mut written = WRITTEN.lock().unwrap_or_else(|e| e.into_inner());
+ if written.len() >= 1 << 15 {
+ written.clear();
+ }
+ written.insert(f.id, entry);
}
fn feature_json(f: &Feature, steps: &StepDigests) -> String {
@@ -2131,6 +2151,7 @@ impl Model {
/// Re-evaluate the document, reusing results up to the first changed feature.
pub fn evaluate(&mut self, doc: &Document) {
self.placement_inputs = None;
+ self.fingerprinted = None;
self.placement_local = true;
let (vals, perr) = evaluation_values(doc);
self.param_errors = perr;
@@ -2532,19 +2553,76 @@ impl Model {
/// Set every result's fingerprint to `doc`'s, so the next evaluation reuses every result
/// (after a change that builds nothing differently).
pub fn refingerprint(&mut self, doc: &Document) {
+ self.refingerprint_from(doc, 0);
+ }
+
+ /// How many leading results keep their fingerprints when `doc` has the body names of the
+ /// features `renamed` pinned, and nothing else changed (see [`Model::refingerprint_shared`]).
+ /// Every command pins, and fingerprinting the whole timeline again for it cost as much as
+ /// the fingerprinting of the evaluation itself. When the results hold `doc`'s fingerprints
+ /// (the address and digest kept when they were given prove it), those before the first
+ /// renamed feature stand, since nothing they read changes, unless a pattern or mirror of
+ /// features among them replays a renamed one (it fingerprints its sources' definitions
+ /// wherever they are). Without that proof: none.
+ pub fn pinned_prefix(&self, doc: &Arc<Document>, renamed: &[u64]) -> usize {
+ let proven = self.fingerprinted.is_some_and(|(of, digest)| of == Arc::as_ptr(doc) as usize && digest == fingerprints_digest(&self.results));
+ if !proven {
+ return 0;
+ }
+ let Some(first) = doc.features.iter().position(|f| renamed.contains(&f.id)) else { return doc.features.len() };
+ let replays_renamed = |f: &Feature| match &f.kind {
+ FeatureKind::Pattern { features, bodies, .. } | FeatureKind::Mirror { features, bodies, .. } => {
+ bodies.is_empty() && !features.is_empty() && replayed_sources(doc, features).iter().any(|g| renamed.contains(&g.id))
+ }
+ _ => false,
+ };
+ doc.features.iter().take(first).position(replays_renamed).unwrap_or(first)
+ }
+
+ /// Drop the proof [`Model::pinned_prefix`] reads: the document at that address is about to
+ /// change in place.
+ pub fn forget_fingerprints(&mut self) {
+ self.fingerprinted = None;
+ }
+
+ /// Fingerprint the results from `start` on for `doc`, chained onto the fingerprint before.
+ pub(crate) fn refingerprint_from(&mut self, doc: &Document, start: usize) {
self.placement_inputs = None;
+ self.fingerprinted = None;
+ self.step_digests = StepDigests::of(doc, &self.step_digests);
+ let start = start.min(self.results.len()).min(doc.features.len());
+ if start == self.results.len().min(doc.features.len()) {
+ return;
+ }
let (vals, _) = evaluation_values(doc);
let marker = doc.marker.unwrap_or(usize::MAX);
- self.step_digests = StepDigests::of(doc, &self.step_digests);
- let mut prev = 0;
+ let last = start.checked_sub(1).and_then(|i| self.results.get(i));
+ let mut prev = last.map_or(0, |r| r.fingerprint);
// Each feature's fingerprint reads the model it starts from, as evaluating does.
- let mut before = Arc::new(ModelState::default());
- for (i, (r, f)) in self.results.iter_mut().zip(&doc.features).enumerate() {
+ let mut before = last.map_or_else(|| Arc::new(ModelState::default()), |r| r.state.clone());
+ for (i, (r, f)) in self.results.iter_mut().zip(&doc.features).enumerate().skip(start) {
prev = chain_fingerprint(doc, &vals, f, prev, i >= marker, &self.step_digests, Some(&before));
r.fingerprint = prev;
before = r.state.clone();
}
}
+
+ /// Note that the results now hold `doc`'s fingerprints (for [`Model::pinned_prefix`]).
+ pub(crate) fn mark_fingerprinted(&mut self, doc: &Arc<Document>) {
+ self.fingerprinted = Some((Arc::as_ptr(doc) as usize, fingerprints_digest(&self.results)));
+ }
+}
+
+/// A digest of the results' features and fingerprints, which proves they are still the ones
+/// [`Model::mark_fingerprinted`] saw (whatever changed them since).
+fn fingerprints_digest(results: &[FeatureResult]) -> u64 {
+ let mut h = std::collections::hash_map::DefaultHasher::new();
+ results.len().hash(&mut h);
+ for r in results {
+ r.id.hash(&mut h);
+ r.fingerprint.hash(&mut h);
+ }
+ h.finish()
}
/// Key of the design's length unit (mm per unit) among the values (no parameter can be named
diff --git a/crates/doc/src/eval_cost_tests.rs b/crates/doc/src/eval_cost_tests.rs
index 8139c60a21..360eeaeb3a 100644
--- a/crates/doc/src/eval_cost_tests.rs
+++ b/crates/doc/src/eval_cost_tests.rs
@@ -36,6 +36,22 @@ pub(super) fn count(f: impl FnOnce(&mut Counts)) {
});
}
+thread_local! {
+ static WRITTEN: Cell<usize> = const { Cell::new(0) };
+}
+
+/// A feature written out on this thread to be fingerprinted.
+pub(super) fn count_written() {
+ WRITTEN.with(|c| c.set(c.get() + 1));
+}
+
+/// The features `f` writes out on this thread to fingerprint them.
+fn written(f: impl FnOnce()) -> usize {
+ WRITTEN.with(|c| c.set(0));
+ f();
+ WRITTEN.with(Cell::get)
+}
+
/// The work `f` does on this thread.
fn counted(f: impl FnOnce()) -> Counts {
COUNTS.with(|c| c.set(Counts::default()));
@@ -358,6 +374,132 @@ fn an_imported_file_is_fingerprinted_by_its_text() {
assert_eq!(model.state().bodies.len(), 3);
}
+/// Pinning body names fingerprints the timeline again only from the first renamed feature on
+/// (`Model::pinned_prefix`), and gives the fingerprints the full pass gives: random pins
+/// on a timeline of boxes, cuts, patterns of features (one placed before its source, as one made
+/// with the timeline rolled back is), a suppressed feature and a history marker, after an
+/// evaluation and after earlier pins.
+#[test]
+fn pinning_body_names_fingerprints_as_the_full_pass_does() {
+ let kind = |v: serde_json::Value| serde_json::from_value::<FeatureKind>(v).unwrap();
+ let mut doc = Document::new("pins");
+ let mut ids = Vec::new();
+ for i in 0..10 {
+ let x = 20.0 * i as f64;
+ let b =
+ kind(serde_json::json!({"type": "box", "corner": [x, 0.0, 0.0], "length": "10", "width": "10", "height": "10", "operation": "new_body"}));
+ ids.push(doc.add_feature(b, None).unwrap());
+ if i % 3 == 1 {
+ let c = kind(
+ serde_json::json!({"type": "cylinder", "axis": [0.0, 0.0, 1.0], "base": [x + 5.0, 5.0, -1.0], "height": "12", "radius": "2", "operation": "cut"}),
+ );
+ ids.push(doc.add_feature(c, None).unwrap());
+ }
+ }
+ let circular = |features: Vec<u64>| {
+ kind(serde_json::json!({"type": "pattern", "features": features, "bodies": [],
+ "pattern": {"type": "circular", "angle": "360 deg", "axis": [0.0, 0.0, 1.0], "count": "3", "origin": [0.0, -40.0, 0.0]}}))
+ };
+ ids.push(doc.add_feature(circular(vec![ids[2]]), None).unwrap());
+ // A pattern of a later feature, placed early in the timeline.
+ let early = doc.add_feature(circular(vec![ids[9]]), None).unwrap();
+ let at = doc.features.iter().position(|f| f.id == early).unwrap();
+ let f = doc.features.remove(at);
+ doc.features.insert(3, f);
+ ids.push(early);
+ doc.feature_mut(ids[5]).unwrap().suppressed = true;
+
+ let mut seed = 0x2545_f491_4f6c_dd1du64;
+ let mut next = |n: usize| {
+ seed ^= seed << 13;
+ seed ^= seed >> 7;
+ seed ^= seed << 17;
+ (seed % n as u64) as usize
+ };
+ let fps = |m: &Model| m.results.iter().map(|r| (r.id, r.fingerprint)).collect::<Vec<_>>();
+ let mut old = Arc::new(doc);
+ let mut model = Model::new();
+ model.evaluate_shared(&old);
+ let (mut proven, mut kept) = (0, 0);
+ for round in 0..60 {
+ if round % 20 == 10 {
+ // From an evaluation's fingerprints again, with the marker in some rounds.
+ let mut d = (*old).clone();
+ d.marker = (round == 30).then_some(d.features.len() - 2);
+ old = Arc::new(d);
+ model.evaluate_shared(&old);
+ }
+ let mut new = (*old).clone();
+ let mut renamed = Vec::new();
+ for _ in 0..1 + next(3) {
+ let f = &mut new.features[next(old.features.len())];
+ let slot = next(3);
+ f.body_names.resize(f.body_names.len().max(slot + 1), String::new());
+ f.body_names[slot] = format!("Pinned {round} {slot}");
+ renamed.push(f.id);
+ }
+ new.reserved_body_names.insert(format!("Body{}", 100 + round));
+ let new = Arc::new(new);
+ let start = model.pinned_prefix(&old, &renamed);
+ let first = new.features.iter().position(|f| renamed.contains(&f.id)).unwrap();
+ assert!(start <= first, "round {round}: kept {start} past the first renamed feature {first}");
+ proven += usize::from(start > 0);
+ kept += start;
+ let mut partial = model.clone();
+ partial.refingerprint_shared(&new, start);
+ let mut full = model.clone();
+ full.refingerprint_shared(&new, 0);
+ assert_eq!(fps(&partial), fps(&full), "round {round}");
+ assert_ne!(fps(&partial), fps(&model), "round {round}: the names are fingerprinted");
+ // The pinned fingerprints prove themselves for the next pin, as the full pass's do.
+ assert_eq!(partial.fingerprinted.as_ref().map(|(_, d)| *d), full.fingerprinted.as_ref().map(|(_, d)| *d));
+ model = partial;
+ old = new;
+ }
+ assert!(proven > 40 && kept > 0, "the stored fingerprints were reused: {proven} rounds, {kept} results");
+
+ // No proof, no reuse: results changed since, another design, or the design about to change
+ // in place.
+ let last = [*ids.last().unwrap()];
+ assert!(model.pinned_prefix(&old, &last) > 0);
+ let mut changed = model.clone();
+ changed.results[0].fingerprint ^= 1;
+ assert_eq!(changed.pinned_prefix(&old, &last), 0);
+ assert_eq!(model.pinned_prefix(&Arc::new((*old).clone()), &last), 0);
+ let mut forgot = model.clone();
+ forgot.forget_fingerprints();
+ assert_eq!(forgot.pinned_prefix(&old, &last), 0);
+}
+
+/// A design evaluated ahead, on a worker thread of its own, fingerprints its features from the
+/// texts the window's evaluation wrote: none is written out again there (the store was per
+/// thread, and every ahead run started it empty), and the fingerprints are the same.
+#[test]
+fn an_evaluation_on_another_thread_reuses_the_written_features() {
+ let mut doc = Document::new("ahead");
+ // Ids no other test's design uses: the store is shared by the tests running beside this one.
+ doc.next_id = 0x0007_e57a_4ead_0000;
+ for i in 0..40 {
+ let x = 20.0 * i as f64;
+ let b = serde_json::json!({"type": "box", "corner": [x, 0.0, 0.0], "length": "10", "width": "10", "height": "10", "operation": "new_body"});
+ doc.add_feature(serde_json::from_value(b).unwrap(), None).unwrap();
+ }
+ let mut window = Model::new();
+ let first = written(|| window.evaluate(&doc));
+ assert!(first >= doc.features.len(), "{first} written");
+ let fps = |m: &Model| m.results.iter().map(|r| r.fingerprint).collect::<Vec<_>>();
+ let (doc2, mut ahead) = (doc.clone(), window.clone());
+ ahead.no_cache = true;
+ let (work, ahead_fps) = std::thread::spawn(move || {
+ let work = written(|| ahead.evaluate(&doc2));
+ (work, fps(&ahead))
+ })
+ .join()
+ .unwrap();
+ assert_eq!(work, 0, "features written out again");
+ assert_eq!(ahead_fps, fps(&window));
+}
+
/// A 10 mm square plate per hole along X, 4 mm thick, in component `comp`, with `holes` square
/// holes cut through it by boxes drawn in component `tools` (the plate's own, usually). The
/// plate's body name.
diff --git a/crates/doc/src/placement_reuse.rs b/crates/doc/src/placement_reuse.rs
index ca861e19de..efa71dc232 100644
--- a/crates/doc/src/placement_reuse.rs
+++ b/crates/doc/src/placement_reuse.rs
@@ -31,6 +31,7 @@ impl Model {
return false;
}
self.evaluate(doc);
+ self.mark_fingerprinted(doc);
if !self.no_cache && self.primed.is_none() && self.placement_local {
self.placement_inputs = Some(Inputs { document: doc.clone(), state: Arc::downgrade(&self.state()) });
}
@@ -38,13 +39,16 @@ impl Model {
}
/// [`Model::refingerprint`] for a shared document: a proof that held for the results before
- /// is kept for `doc`, since nothing was built differently (pinned body names, say).
- pub fn refingerprint_shared(&mut self, doc: &Arc<Document>) {
+ /// is kept for `doc`, since nothing was built differently (pinned body names, say). The
+ /// first `keep` results keep their fingerprints: [`Model::pinned_prefix`] of the document
+ /// before the pins, or 0.
+ pub fn refingerprint_shared(&mut self, doc: &Arc<Document>, keep: usize) {
let proven = !self.no_cache
&& self.primed.is_none()
&& self.placement_inputs.as_ref().is_some_and(|inputs| inputs.state.upgrade().is_some_and(|state| Arc::ptr_eq(&state, &self.state())))
&& !self.is_stale();
- self.refingerprint(doc);
+ self.refingerprint_from(doc, keep);
+ self.mark_fingerprinted(doc);
if proven && self.placement_local {
self.placement_inputs = Some(Inputs { document: doc.clone(), state: Arc::downgrade(&self.state()) });
}
diff --git a/crates/engine/src/cmd/edit_tests.rs b/crates/engine/src/cmd/edit_tests.rs
index 79051e8c48..513d167f22 100644
--- a/crates/engine/src/cmd/edit_tests.rs
+++ b/crates/engine/src/cmd/edit_tests.rs
@@ -1108,6 +1108,57 @@ fn counted_body_names_stay_when_the_timeline_changes() {
assert_eq!(bodies(&s), named(&[("Body2", "B"), ("Body3", "C"), ("Body4", "E")]));
}
+/// Pinning reads each feature's bodies once and keeps them with the state it read them from;
+/// the names it pins and reserves, and the fingerprints it leaves, are those of reading every
+/// feature's bodies again: random boxes (named and counted), moves, suppressions, deletions,
+/// reorders, undo and redo, against a session that forgets what it read before every command and
+/// against fingerprinting the whole timeline again.
+#[test]
+fn pinning_with_the_bodies_it_read_before_pins_as_reading_them_again() {
+ let (mut kept, mut fresh) = (Session::default(), Session::default());
+ let mut seed = 0x9e37_79b9_7f4a_7c15u64;
+ let mut next = |n: usize| {
+ seed ^= seed << 13;
+ seed ^= seed >> 7;
+ seed ^= seed << 17;
+ (seed % n as u64) as usize
+ };
+ for step in 0..60 {
+ let features: Vec<String> = kept.doc.features.iter().map(|f| f.name.clone()).collect();
+ let counted: Vec<String> = kept.model.state().bodies.iter().map(|b| b.name.clone()).collect();
+ let pick = |names: &[String], k: usize| names.get(k % names.len().max(1)).cloned().unwrap_or_default();
+ let x = 15 * step;
+ let (id, params) = match next(9) {
+ _ if features.len() < 3 => ("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0]})),
+ 0 | 1 => ("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0]})),
+ 2 => ("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "body_name": format!("Named {step}")})),
+ 3 => ("solid.move", json!({"bodies": [pick(&counted, next(64))], "translate": [0, 5, 0]})),
+ 4 => ("timeline.suppress", json!({"feature": pick(&features, next(64)), "suppressed": next(2) == 0})),
+ 5 => ("timeline.delete", json!({"feature": pick(&features, next(64))})),
+ 6 => ("timeline.reorder", json!({"feature": pick(&features, next(64)), "position": next(features.len()), "active": true})),
+ 7 => ("edit.undo", json!({})),
+ _ => ("edit.redo", json!({})),
+ };
+ fresh.made_bodies.clear();
+ let (a, b) = (kept.execute(id, &params), fresh.execute(id, &params));
+ assert_eq!(a.is_ok(), b.is_ok(), "step {step}: {id} {params}");
+ assert_eq!(kept.doc.to_json(), fresh.doc.to_json(), "step {step}: {id} {params}");
+ // The fingerprints match the design as fingerprinting the whole timeline again makes them
+ // match it: evaluating it again reuses the same results (all, as a rule; the others are
+ // computed or taken from the cache the copies share).
+ let again = |model: &solidcraft_doc::Model| {
+ let mut m = model.clone();
+ m.evaluate(&kept.doc);
+ m.last_recomputed + m.last_restored
+ };
+ let mut full = kept.model.clone();
+ full.refingerprint(&kept.doc);
+ assert_eq!(again(&kept.model), again(&full), "step {step}: {id} {params}");
+ assert_eq!(again(&kept.model), again(&fresh.model), "step {step}: {id} {params}");
+ }
+ assert!(kept.doc.features.len() > 5 && !kept.doc.reserved_body_names.is_empty());
+}
+
/// The value at a dotted path of a definition.
fn dotted<'a>(def: &'a Value, path: &str) -> &'a Value {
path.split('.').fold(def, |v, k| &v[k])
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 08aa94c6b5..11ffd16542 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -424,6 +424,9 @@ impl ComputedCommands {
/// reports how it went and opens the answer itself. `Err`: it couldn't start.
pub type EasyPrintUpload = Arc<dyn Fn(&str, Vec<u8>) -> std::result::Result<(), String> + Send + Sync>;
+/// See [`Session::made_bodies`].
+type MadeBodies = std::collections::HashMap<u64, (std::sync::Weak<ModelState>, Vec<String>)>;
+
pub struct Session {
pub doc: Arc<Document>,
pub model: Model,
@@ -492,6 +495,9 @@ pub struct Session {
/// 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<Option<occurrences::VisibilityIndex>>,
+ /// The bodies each feature made, by name, with the state they were read from
+ /// ([`Session::pin_body_names`]).
+ made_bodies: MadeBodies,
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>>,
@@ -700,6 +706,7 @@ impl Session {
joints_settled: None,
occurrence_visibility_cache: Default::default(),
visibility_index_cache: Default::default(),
+ made_bodies: MadeBodies::new(),
removed_later_cache: Default::default(),
occurrence_bodies_cache: Default::default(),
placement_index_cache: Default::default(),
@@ -903,6 +910,7 @@ impl Session {
*index = None;
}
self.forget_dirty_answer();
+ self.model.forget_fingerprints();
Arc::make_mut(&mut self.doc)
}
@@ -1128,12 +1136,34 @@ impl Session {
}
let mut pins: Vec<(u64, Vec<String>)> = Vec::new();
let mut reserve: Vec<String> = Vec::new();
- for f in self.doc.features.iter().filter(|f| !matches!(f.kind, solidcraft_doc::FeatureKind::FrameMember { .. })) {
- let Some(r) = self.model.result(f.id).filter(|r| r.error.is_none() && !r.skipped && !r.stale) else { continue };
- let made: Vec<&str> = r.state.bodies.iter().filter(|b| b.feature == f.id).map(|b| b.name.as_str()).collect();
+ // The names of the bodies each feature made, kept with the state they were read from:
+ // every command pins, and reading them again searched every result's bodies (features ×
+ // bodies per command). A state is the same while it is the same allocation (the weak
+ // reference keeps that address from being reused), and its bodies never change in place.
+ let mut known = std::mem::take(&mut self.made_bodies);
+ let mut made_bodies = MadeBodies::with_capacity(known.len());
+ for (i, f) in self.doc.features.iter().enumerate() {
+ if matches!(f.kind, solidcraft_doc::FeatureKind::FrameMember { .. }) {
+ continue;
+ }
+ // Results are in timeline order: the feature's own index first, the search only when not.
+ let r = self.model.results.get(i).filter(|r| r.id == f.id).or_else(|| self.model.result(f.id));
+ let Some(r) = r.filter(|r| r.error.is_none() && !r.skipped && !r.stale) else { continue };
+ let made = match known.remove(&f.id).filter(|(state, _)| std::sync::Weak::as_ptr(state) == Arc::as_ptr(&r.state)) {
+ Some(entry) => made_bodies.entry(f.id).or_insert(entry),
+ None => made_bodies.entry(f.id).or_insert_with(|| {
+ let names = r.state.bodies.iter().filter(|b| b.feature == f.id).map(|b| b.name.clone()).collect();
+ (Arc::downgrade(&r.state), names)
+ }),
+ };
+ let made: Vec<&str> = made.1.iter().map(String::as_str).collect();
reserve.extend(
made.iter().filter(|n| solidcraft_doc::is_counted_body_name(n) && !self.doc.reserved_body_names.contains(**n)).map(|n| n.to_string()),
);
+ // Nothing to pin when every slot the bodies take already holds a name.
+ if made.len() <= f.body_names.len() && f.body_names.iter().take(made.len()).all(|slot| !slot.trim().is_empty()) {
+ continue;
+ }
let mut names = f.body_names.clone();
names.resize(names.len().max(made.len()), String::new());
for (slot, name) in names.iter_mut().zip(&made) {
@@ -1145,9 +1175,13 @@ impl Session {
pins.push((f.id, names));
}
}
+ self.made_bodies = made_bodies;
if pins.is_empty() && reserve.is_empty() {
return;
}
+ // The fingerprints that stand: taken before the pins change the design.
+ let renamed: Vec<u64> = pins.iter().map(|(id, _)| *id).collect();
+ let keep = self.model.pinned_prefix(&self.doc, &renamed);
let doc = self.doc_mut();
for (id, names) in pins {
if let Some(f) = doc.feature_mut(id) {
@@ -1156,7 +1190,7 @@ impl Session {
}
doc.reserved_body_names.extend(reserve);
// The pinned names are the ones the bodies have: no result changes, so none is evaluated.
- self.model.refingerprint_shared(&self.doc);
+ self.model.refingerprint_shared(&self.doc, keep);
}
/// A hidden construction plane stays hidden when the design renames it, or undo or redo
@@ -1632,6 +1666,9 @@ impl Session {
pending_moves: self.pending_moves.clone(),
world_cache: std::sync::Mutex::new(self.world_cache.lock().ok().and_then(|cache| cache.clone())),
joints_settled: self.joints_settled.clone(),
+ // Read again by the copy: handing it these references measured more peak memory on a
+ // large design (the rover, evaluated ahead) for no change in what it pins.
+ made_bodies: MadeBodies::new(),
occurrence_visibility_cache: Default::default(),
visibility_index_cache: Default::default(),
removed_later_cache: Default::default(),