SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Preserve unchanged results when rolling the timeline (#6008) (#6067)
Colin Faulkingham12b0d9dbfffc
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 4ff701cd38..ee5a46b5f0 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -1183,6 +1183,10 @@ pub struct Model {step_digests: StepDigests,/// 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+ /// context. These share the existing states, so rolling back does not surrender them to+ /// the bounded cache. A result leaves this map when its feature is active again or removed.+ rolled_results: std::collections::HashMap<u64, (u64, FeatureResult)>,/// Results another copy of this model evaluated (ahead, off the window thread) that/// `evaluate` takes for features they match ([`Model::prime`]), with that copy's context.primed: Option<(u64, Arc<std::collections::HashMap<u64, FeatureResult>>)>,@@ -1966,6 +1970,8 @@ impl Model {let mut restored = 0;let marker = doc.marker.unwrap_or(usize::MAX);let ctx = context_digest(doc, &vals);+ let previous_context = self.context;+ let mut rolled_results = std::mem::take(&mut self.rolled_results);self.context = ctx;self.step_digests = StepDigests::of(doc, &self.step_digests);let primed = self.primed.as_ref().filter(|(context, _)| !self.no_cache && *context == ctx).map(|(_, results)| results.clone());@@ -1978,6 +1984,20 @@ impl Model {let watched = crate::progress::begin(doc.features.len());for (i, f) in doc.features.iter().enumerate() {let rolled_back = i >= marker;+ // Retain at most one active result per rolled-back feature, even across several+ // marker moves. Build the map anew so deleted features release their states too.+ let rolled = rolled_results.remove(&f.id);+ let rolled = if self.no_cache {+ None+ } else if rolled_back {+ let active = self.results.get(i).filter(|r| r.id == f.id && !r.skipped && !r.stale && !r.unkept);+ if let Some(saved) = active.map(|r| (previous_context, r.clone())).or(rolled) {+ self.rolled_results.insert(f.id, saved);+ }+ None+ } else {+ rolled.filter(|(context, _)| *context == ctx).map(|(_, r)| r)+ };// Opening was cancelled: the rest is skipped and the result discarded.let cancelled = watched.step(i);let fp = chain_fingerprint(doc, &vals, f, prev_fp, rolled_back, &self.step_digests, Some(&state));@@ -2052,8 +2072,9 @@ impl Model {});continue;}- // Evaluated ahead on these same inputs (the same chain of definitions from the start).- if let Some(r) = primed.as_ref().and_then(|p| p.get(&f.id)).filter(|r| r.fingerprint == fp && !r.stale && !r.skipped) {+ // An active result hidden by the marker, or evaluated ahead on these same inputs+ // (the same chain of definitions from the start). Changed inputs never reuse it.+ if let Some(r) = rolled.as_ref().filter(current).or_else(|| primed.as_ref().and_then(|p| p.get(&f.id)).filter(current)) {restored += 1;if r.error.is_none() {state = r.state.clone();diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rsindex 4b673dfe6c..2908b55eef 100644--- a/crates/doc/src/model_cache.rs+++ b/crates/doc/src/model_cache.rs@@ -618,7 +618,7 @@ impl Model {}results.push(result);}- let mut model = Model { results, param_errors, step_digests, frame_bodies, ..Model::default() };+ let mut model = Model { results, param_errors, step_digests, context: ctx, frame_bodies, ..Model::default() };let unkept = model.results.iter().filter(|r| r.unkept).count();if unkept > 0 {// The features whose state the file did not keep, each evaluated again from the statediff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rsindex 5acee029bb..4ab66fbfcc 100644--- a/crates/doc/src/tests.rs+++ b/crates/doc/src/tests.rs@@ -125,6 +125,97 @@ fn results_kept_ahead_outlive_the_cache() {assert!(rel(measure(&m.state().bodies[0].body).unwrap().volume, 30000.0) < 1e-9);}+/// Rolling the marker back must not discard unchanged results just because the bounded cache+/// evicted them. Opening an earlier feature and returning to the end otherwise rebuilds it all.+#[test]+fn rolling_the_marker_back_keeps_results_after_cache_eviction() {+ for reopen in [false, true] {+ let (mut doc, _) = plate_doc();+ let mut m = Model::new();+ m.evaluate(&doc);+ if reopen {+ m = Model::adopt(&doc, &m.saved(&doc).unwrap()).unwrap();+ }+ let finished = m.state();+ let computed = m.recomputed;+ // Simulate eviction by previews or the cache's byte limit, without a large/slow fixture.+ *m.cache.lock().unwrap() = Default::default();+ for marker in [Some(1), Some(0), Some(1), None] {+ doc.marker = marker;+ m.evaluate(&doc);+ assert_eq!(m.recomputed, computed, "reopen {reopen}, marker {marker:?}: unchanged features must be reused");+ assert_eq!(m.state().bodies.len(), usize::from(marker.is_none()));+ }+ assert!(std::sync::Arc::ptr_eq(&m.state(), &finished), "return to the original evaluated state");+ }+}++#[test]+fn rolling_a_large_unchanged_timeline_forward_reuses_its_geometry() {+ let mut doc = Document::new("marker cache budget");+ for i in 0..80 {+ doc.add_feature(+ FeatureKind::Box {+ corner: point_expr(Vec3::new((i % 10) as f64 * 15.0, (i / 10) as f64 * 15.0, 0.0)),+ length: "10".into(),+ width: "10".into(),+ height: "10".into(),+ operation: Operation::NewBody,+ },+ None,+ )+ .unwrap();+ }+ let mut m = Model::new();+ m.evaluate(&doc);+ assert!(m.results.iter().all(|r| r.error.is_none()));+ // Exceed the actual byte budget without manually clearing the cache.+ assert!(m.results.iter().map(|r| r.state.retained_bytes()).sum::<usize>() > 64 << 20);+ let finished = m.state();+ doc.marker = Some(1);+ m.evaluate(&doc);+ assert_eq!(m.state().bodies.len(), 1);+ doc.marker = None;+ m.evaluate(&doc);+ assert_eq!(m.last_recomputed, 0, "returning to the end must not rebuild unchanged boxes");+ assert_eq!(m.state().bodies.len(), 80);+ assert!(std::sync::Arc::ptr_eq(&m.state(), &finished));+}++#[test]+fn rolled_results_never_mask_edits_or_disabled_reuse() {+ for change in ["parameter", "feature", "suppressed", "units", "no_cache"] {+ let (mut doc, _) = plate_doc();+ let mut m = Model::new();+ m.evaluate(&doc);+ doc.marker = Some(0);+ m.evaluate(&doc);+ *m.cache.lock().unwrap() = Default::default();+ match change {+ "parameter" => doc.set_param("width", "50 mm", None, None).unwrap(),+ "feature" => {+ let FeatureKind::Extrude { extent, .. } = &mut doc.features[1].kind else { panic!("extrude") };+ extent.distance = "25".into();+ }+ "suppressed" => doc.features[1].suppressed = true,+ "units" => doc.units = "in".into(),+ "no_cache" => m.no_cache = true,+ _ => panic!("unknown edit case"),+ }+ doc.marker = None;+ m.evaluate(&doc);+ let mut fresh = Model::new();+ fresh.evaluate(&doc);+ let volume = |model: &Model| model.state().bodies.iter().map(|b| measure(&b.body).unwrap().volume).sum::<f64>();+ assert_eq!(m.state().bodies.len(), fresh.state().bodies.len(), "{change}");+ assert!((volume(&m) - volume(&fresh)).abs() < 1e-6, "{change}: retained geometry must match a fresh evaluation");+ assert_eq!(m.results.iter().map(|r| &r.error).collect::<Vec<_>>(), fresh.results.iter().map(|r| &r.error).collect::<Vec<_>>(), "{change}");+ if matches!(change, "parameter" | "feature" | "units" | "no_cache") {+ assert!(m.last_recomputed > 0, "{change}: changed inputs must rebuild");+ }+ }+}+#[test]fn box_fillet_cut_timeline() {let (mut doc, _) = plate_doc();