Preserve unchanged results when rolling the timeline (#6008) (#6067)

* claim: #6008

* Reuse rolled-back timeline results after cache eviction
This commit is contained in:
Colin Faulkingham
2026-10-26 10:42:32 +00:00
committed by GitHub
parent 613903229e
commit 12b0d9dbff
3 changed files with 115 additions and 3 deletions
+23 -2
View File
@@ -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();
+1 -1
View File
@@ -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
+91
View File
@@ -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();