Skip to content

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.rs
index 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.rs
index 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 state
diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rs
index 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();