From 12b0d9dbfffcab53cca679b8430c489e80f90540 Mon Sep 17 00:00:00 2001 From: Colin Faulkingham Date: Mon, 26 Oct 2026 10:42:32 +0000 Subject: [PATCH] Preserve unchanged results when rolling the timeline (#6008) (#6067) * claim: #6008 * Reuse rolled-back timeline results after cache eviction --- crates/doc/src/eval.rs | 25 +++++++++- crates/doc/src/model_cache.rs | 2 +- crates/doc/src/tests.rs | 91 +++++++++++++++++++++++++++++++++++ 3 files changed, 115 insertions(+), 3 deletions(-) diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index 4ff701cd3..ee5a46b5f 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, /// 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>)>, @@ -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 4b673dfe6..2908b55ee 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 5acee029b..4ab66fbfc 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::() > 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::(); + 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::>(), fresh.results.iter().map(|r| &r.error).collect::>(), "{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();