* claim: #6008 * Reuse rolled-back timeline results after cache eviction
This commit is contained in:
committed by
GitHub
parent
613903229e
commit
12b0d9dbff
+23
-2
@@ -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();
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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();
|
||||
|
||||
Reference in New Issue
Block a user