SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Model cache: thin the checkpoints of a design too big for its file instead of leaving the cache out (#3220) (#4882)
Mateusz Syche33c371e9923
diff --git a/apps/solidcraft-cli/src/main.rs b/apps/solidcraft-cli/src/main.rsindex 9b4b06e90b..312e1fce70 100644--- a/apps/solidcraft-cli/src/main.rs+++ b/apps/solidcraft-cli/src/main.rs@@ -723,9 +723,10 @@ pub(crate) fn cmd_bench_open(args: &[String]) -> Result<(), String> {let t = std::time::Instant::now();let s = Session::opened(doc, saved.as_ref());drop(read);- // Taken from the file: nothing evaluated (SOLIDCRAFT_NO_MODEL_CACHE evaluates anyway).+ // Taken from the file: nothing evaluated (SOLIDCRAFT_NO_MODEL_CACHE evaluates anyway), or+ // only the features whose state a thinned file left out.let adopted = saved.is_some() && s.model.last_recomputed == 0;- println!("{}", json!({"step": "evaluate", "ms": t.elapsed().as_secs_f64() * 1000.0, "adopted": adopted}));+ println!("{}", json!({"step": "evaluate", "ms": t.elapsed().as_secs_f64() * 1000.0, "adopted": adopted, "recomputed": s.model.last_recomputed}));for r in &s.model.results {println!("{}", json!({"step": "feature", "id": r.id, "name": r.name, "ms": r.ms, "error": r.error}));}diff --git a/apps/solidcraft-cli/tests/model_cache.rs b/apps/solidcraft-cli/tests/model_cache.rsindex 6d4bab4eb8..42a91adaeb 100644--- a/apps/solidcraft-cli/tests/model_cache.rs+++ b/apps/solidcraft-cli/tests/model_cache.rs@@ -7,7 +7,7 @@ use std::sync::Arc;use serde_json::{Value, json};use solidcraft_engine::Session;-use solidcraft_engine::doc::{ModelBody, ModelState};+use solidcraft_engine::doc::{ModelBody, ModelState, SavedModel};fn corpus() -> Vec<PathBuf> {let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus");@@ -149,6 +149,87 @@ fn imported_assemblies_open_from_their_model_as_evaluated() {check("imported hinge", s);}+/// `built` saved with `saved`, a model of it that keeps only some states (as a file without room+/// for all of them does, #3220), opens as the design evaluated again: evaluating just the+/// features whose state the file left out, then after suppressing a feature at, before or after+/// each state it kept, after undoing that, and with the marker moved there and back.+fn check_thinned(name: &str, built: &Session, saved: &SavedModel) {+ let design = built.design();+ let bytes =+ solidcraft_engine::io::write_design_container_with_cache(&design, solidcraft_engine::io::DesignCompression::Fast, None, Some(saved)).unwrap();+ assert!(solidcraft_engine::io::read_design_geometry(&bytes).is_some(), "{name}: the file keeps the final state");+ let path = temp(&name.replace(' ', "-"));+ std::fs::write(&path, &bytes).unwrap();+ let mut cached = open(&path);+ let mut rebuilt = Session::new(solidcraft_engine::io::read_design(&bytes).unwrap());+ let features = saved.records["features"].as_array().unwrap();+ let unkept = features.iter().filter(|f| f["skipped"] == false && f.get("state").is_none()).count();+ assert!(unkept > 0, "{name}: some states left out");+ assert_eq!(cached.model.recomputed, unkept, "{name}: evaluated just the features whose state the file left out");+ assert_eq!(model(name, &cached), model(name, &rebuilt), "{name}: opened from the file's model");+ let n = cached.doc.features.len();+ let mut at: Vec<usize> = features+ .iter()+ .enumerate()+ .filter(|(_, f)| f["skipped"] == false && f.get("state").is_some())+ .flat_map(|(k, _)| [k.saturating_sub(1), k, k + 1])+ .filter(|i| *i < n)+ .collect();+ at.dedup();+ for i in at {+ let edit = json!({"feature": cached.doc.features[i].id, "suppressed": true});+ let (a, b) = (cached.execute("timeline.suppress", &edit), rebuilt.execute("timeline.suppress", &edit));+ assert_eq!(a.is_ok(), b.is_ok(), "{name}: suppressing feature {i}");+ assert_eq!(model(name, &cached), model(name, &rebuilt), "{name}: feature {i} suppressed");+ if a.is_ok() {+ cached.execute("edit.undo", &json!({})).unwrap();+ rebuilt.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(model(name, &cached), model(name, &rebuilt), "{name}: suppressing feature {i} undone");+ }+ for marker in [json!({"position": i}), json!({})] {+ cached.execute("timeline.rollback", &marker).unwrap();+ rebuilt.execute("timeline.rollback", &marker).unwrap();+ assert_eq!(model(name, &cached), model(name, &rebuilt), "{name}: the marker at {marker}, from feature {i}");+ }+ }+ let _ = std::fs::remove_file(&path);+}++/// A model too big for its file keeps the final state, then the slowest features' states as fit+/// (#3220). Both the smallest such model (the final state, and states that add no body to it)+/// and one that keeps more open as the design evaluated again. The placed components' design has+/// a cut whose fingerprint reads where the bodies before it lie, which a state left out does not+/// say until it is evaluated.+#[test]+fn thinned_models_open_as_evaluated() {+ let corpus = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus/components-arm.solidcraft");+ for sample in ["Sample Plate", "Plastic Enclosure", "components-arm"] {+ let built = match solidcraft_engine::sample::samples().into_iter().find(|s| s.name == sample) {+ Some(s) => {+ let mut built = Session::default();+ for c in (s.script)()["commands"].as_array().unwrap() {+ built.execute(c["command"].as_str().unwrap(), &c["params"]).unwrap();+ }+ built+ }+ None => open(&corpus),+ };+ let saved = built.model.saved(&built.design()).unwrap();+ // Every body a megabyte (the records fit in the room left over): each budget keeps one more+ // body's worth of states.+ let body = 1 << 20;+ let pieces: Vec<Vec<(usize, usize)>> = (0..saved.bodies.len()).map(|i| vec![(i, body)]).collect();+ let thinned: Vec<SavedModel> =+ (0..=saved.bodies.len()).filter_map(|n| saved.thinned(&pieces, n * body + body - 1).map(|(m, _, _)| m)).collect();+ let kept = |m: &SavedModel| m.records["features"].as_array().unwrap().iter().filter(|f| f.get("state").is_some()).count();+ let smallest = thinned.first().unwrap();+ assert!(smallest.records["states"].as_array().unwrap().len() < saved.records["states"].as_array().unwrap().len(), "{sample}");+ let more = thinned.iter().find(|m| kept(m) > kept(smallest) && kept(m) < built.doc.features.len()).unwrap();+ check_thinned(&format!("{sample} smallest"), &built, smallest);+ check_thinned(&format!("{sample} thinned"), &built, more);+ }+}+/// Opened from its model, a design evaluates only from the first feature an edit changes: the/// saved states before it are kept as they were read (the same states, not evaluated again).#[test]diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex d8a982a672..f08180adf9 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -1023,6 +1023,11 @@ pub struct FeatureResult {pub stale: bool,#[serde(skip)]fingerprint: u64,+ /// Taken from a saved model that did not keep this feature's state (#3220): `state` only+ /// stands in for it until [`Model::evaluate`] evaluates the feature again, which+ /// [`Model::adopt`] does before the model is used.+ #[serde(skip)]+ unkept: bool,#[serde(skip)]pub state: Arc<ModelState>,}@@ -1792,11 +1797,13 @@ impl Model {let cancelled = watched.step(i);let fp = chain_fingerprint(doc, &vals, f, prev_fp, rolled_back, &self.step_digests, Some(&state));prev_fp = fp;+ let current = |old: &&FeatureResult| old.id == f.id && old.fingerprint == fp && !old.stale;+ // A state the saved model did not keep is evaluated again from the one before it; the+ // results after it that the model did keep still stand (#3220).+ let unkept = reuse && self.results.get(i).filter(current).is_some_and(|old| old.unkept);if reuse- && let Some(old) = self.results.get(i)- && old.id == f.id- && old.fingerprint == fp- && !old.stale+ && !unkept+ && let Some(old) = self.results.get(i).filter(current){if !old.skipped {state = old.state.clone();@@ -1804,7 +1811,7 @@ impl Model {out.push(old.clone());continue;}- reuse = false;+ reuse = unkept && !cancelled;if f.suppressed || rolled_back || cancelled {out.push(FeatureResult {id: f.id,@@ -1816,6 +1823,7 @@ impl Model {skipped: true,stale: false,fingerprint: fp,+ unkept: false,state: state.clone(),});continue;@@ -1833,6 +1841,8 @@ impl Model {if c.error.is_none() {state = c.state.clone();}+ // A kept result after a failed one would not be this evaluation's.+ reuse &= c.error.is_none();out.push(FeatureResult {id: f.id,name: f.name.clone(),@@ -1843,6 +1853,7 @@ impl Model {skipped: false,stale: false,fingerprint: fp,+ unkept: false,state: state.clone(),});continue;@@ -1853,7 +1864,8 @@ impl Model {if r.error.is_none() {state = r.state.clone();}- out.push(FeatureResult { state: state.clone(), ..r.clone() });+ reuse &= r.error.is_none();+ out.push(FeatureResult { state: state.clone(), unkept: false, ..r.clone() });continue;}recomputed += 1;@@ -1985,6 +1997,7 @@ impl Model {m.put(key, e);}}+ reuse &= error.is_none();out.push(FeatureResult {id: f.id,name: f.name.clone(),@@ -1995,6 +2008,7 @@ impl Model {skipped: false,stale: false,fingerprint: fp,+ unkept: false,state: state.clone(),});}diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rsindex 2a9639bb37..b5062aa501 100644--- a/crates/doc/src/model_cache.rs+++ b/crates/doc/src/model_cache.rs@@ -6,7 +6,8 @@//! hold (one that later features pass through unchanged) is recorded once, as are its face names//! and the solved sketches the states share. Face names are kept as worked out, not as the//! history they were worked out from: a model taken from a file names every face as the model-//! that was saved did.+//! that was saved did. A file without room for every state keeps fewer+//! ([`SavedModel::thinned`]); opening evaluates the features whose state it left out again.use super::*;use crate::history_names::{FaceInfo, Names};@@ -359,12 +360,163 @@ impl SavedModel {None => Ok(Arc::new(ModelState::default())),}}++ /// This model with fewer states, for a design file without room for all of them (#3220): the+ /// final state (what the design shows, kept whatever it costs), then the others, the slowest+ /// feature's first (the ones opening would take longest to evaluate again; of equal ones the+ /// later first), each while what it adds still fits in `budget` bytes: the bodies no state kept+ /// so far holds, and the records of the state, those bodies, their names and sketches.+ /// `pieces[i]` is what keeping body `i` stores, as ids and bytes: a piece that several bodies+ /// or states need counts once. A feature whose state is left out keeps none, and opening+ /// evaluates it again ([`Model::adopt`]). With the model, the index here of each body it keeps,+ /// and the bytes it counted: over `budget` when the final state alone is. `None` only for+ /// records it cannot read.+ pub fn thinned(&self, pieces: &[Vec<(usize, usize)>], budget: usize) -> Option<(SavedModel, Vec<usize>, usize)> {+ let list = |key: &str| self.records.get(key).and_then(Json::as_array);+ let (features, states, model_bodies) = (list("features")?, list("states")?, list("model_bodies")?);+ let (names, sketches) = (list("names")?, list("sketches")?);+ let at = |v: Option<&Json>, len: usize| v.and_then(Json::as_u64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < len);+ // The indices a state's runs list.+ let held = |s: &Json, key: &str, len: usize| -> Option<Vec<usize>> {+ let mut out = Vec::new();+ for run in s.get(key)?.as_array()? {+ let first = at(run.get(0), len)?;+ out.extend(first..first.checked_add(at(run.get(1), len.saturating_add(1))?).filter(|end| *end <= len)?);+ }+ Some(out)+ };+ let state_bodies = states.iter().map(|s| held(s, "bodies", model_bodies.len())).collect::<Option<Vec<_>>>()?;+ let state_sketches = states.iter().map(|s| held(s, "sketches", sketches.len())).collect::<Option<Vec<_>>>()?;+ let body_of = model_bodies.iter().map(|r| at(r.get("body"), self.bodies.len())).collect::<Option<Vec<_>>>()?;+ let names_of = model_bodies.iter().map(|r| at(r.get("names"), names.len())).collect::<Option<Vec<_>>>()?;+ // What each record takes in the file.+ let bytes = |list: &[Json]| list.iter().map(|r| serde_json::to_vec(r).map_or(usize::MAX, |b| b.len().saturating_add(1))).collect::<Vec<_>>();+ let (state_bytes, body_bytes) = (bytes(states.as_slice()), bytes(model_bodies.as_slice()));+ let (name_bytes, sketch_bytes) = (bytes(names.as_slice()), bytes(sketches.as_slice()));+ // What each state's feature took to evaluate, and the final state.+ let mut ms = vec![0.0f64; states.len()];+ let mut last = None;+ for f in features.iter().filter(|f| f.get("skipped").and_then(Json::as_bool) == Some(false)) {+ let s = at(f.get("state"), states.len())?;+ if let Some(t) = ms.get_mut(s) {+ *t += f.get("ms").and_then(Json::as_f64).filter(|t| t.is_finite() && *t > 0.0).unwrap_or(0.0);+ }+ last = Some(s);+ }+ let last = last?;+ let time = |s: &usize| ms.get(*s).copied().unwrap_or(0.0);+ let mut order: Vec<usize> = (0..states.len()).filter(|s| *s != last).collect();+ order.sort_by(|a, b| time(b).total_cmp(&time(a)).then(b.cmp(a)));+ let mut keep = vec![false; states.len()];+ // The records and pieces kept so far, and their bytes.+ let mut kept_bodies = vec![false; model_bodies.len()];+ let (mut names_used, mut sketches_used) = (vec![false; names.len()], vec![false; sketches.len()]);+ let mut stored = std::collections::HashSet::new();+ let mut used = 0usize;+ for s in std::iter::once(last).chain(order) {+ let (mut adds, mut new_names, mut new_sketches) = (HashMap::new(), std::collections::HashSet::new(), std::collections::HashSet::new());+ let mut records = *state_bytes.get(s)?;+ for &m in state_bodies.get(s)? {+ if kept_bodies.get(m) == Some(&false) {+ records = records.saturating_add(*body_bytes.get(m)?);+ let n = *names_of.get(m)?;+ if names_used.get(n) == Some(&false) && new_names.insert(n) {+ records = records.saturating_add(*name_bytes.get(n)?);+ }+ for &(piece, bytes) in pieces.get(*body_of.get(m)?)? {+ if !stored.contains(&piece) {+ adds.insert(piece, bytes);+ }+ }+ }+ }+ for &k in state_sketches.get(s)? {+ if sketches_used.get(k) == Some(&false) && new_sketches.insert(k) {+ records = records.saturating_add(*sketch_bytes.get(k)?);+ }+ }+ let total = adds.values().fold(used.saturating_add(records), |t, b| t.saturating_add(*b));+ if total > budget && s != last {+ continue;+ }+ used = total;+ stored.extend(adds.into_keys());+ for &m in state_bodies.get(s)? {+ *kept_bodies.get_mut(m)? = true;+ }+ for n in new_names {+ *names_used.get_mut(n)? = true;+ }+ for k in new_sketches {+ *sketches_used.get_mut(k)? = true;+ }+ *keep.get_mut(s)? = true;+ }+ // What the states kept refer to, numbered again in the order it had.+ let mut kernel_used = vec![false; self.bodies.len()];+ for m in (0..model_bodies.len()).filter(|m| kept_bodies.get(*m) == Some(&true)) {+ *kernel_used.get_mut(*body_of.get(m)?)? = true;+ }+ let renumber = |used: &[bool]| -> Vec<Option<usize>> {+ let mut next = 0;+ used.iter()+ .map(|&u| {+ u.then(|| {+ next += 1;+ next - 1+ })+ })+ .collect()+ };+ let (new_body, new_kernel, new_names) = (renumber(&kept_bodies), renumber(&kernel_used), renumber(&names_used));+ let (new_sketch, new_state) = (renumber(&sketches_used), renumber(&keep));+ let new = |map: &[Option<usize>], i: usize| map.get(i).copied().flatten();+ let kept_of = |list: &[Json], used: &[bool]| list.iter().zip(used).filter(|(_, u)| **u).map(|(v, _)| v.clone()).collect::<Vec<_>>();+ let mut out_states = Vec::new();+ for (s, st) in states.iter().enumerate().filter(|(s, _)| keep.get(*s) == Some(&true)) {+ let bodies = state_bodies.get(s)?.iter().map(|m| new(&new_body, *m)).collect::<Option<Vec<_>>>()?;+ let sketches = state_sketches.get(s)?.iter().map(|i| new(&new_sketch, *i)).collect::<Option<Vec<_>>>()?;+ let mut st = st.clone();+ let o = st.as_object_mut()?;+ o.insert("bodies".into(), json!(runs(&bodies)));+ o.insert("sketches".into(), json!(runs(&sketches)));+ out_states.push(st);+ }+ let mut out_bodies = Vec::new();+ for (m, r) in model_bodies.iter().enumerate().filter(|(m, _)| kept_bodies.get(*m) == Some(&true)) {+ let (body, named) = (new(&new_kernel, *body_of.get(m)?)?, new(&new_names, at(r.get("names"), names.len())?)?);+ let mut r = r.clone();+ let o = r.as_object_mut()?;+ o.insert("body".into(), json!(body));+ o.insert("names".into(), json!(named));+ out_bodies.push(r);+ }+ let mut out_features = Vec::with_capacity(features.len());+ for f in features {+ let state = new(&new_state, at(f.get("state"), states.len())?);+ let mut f = f.clone();+ let o = f.as_object_mut()?;+ match state {+ Some(s) => o.insert("state".into(), json!(s)),+ None => o.remove("state"),+ };+ out_features.push(f);+ }+ let records = json!({+ "features": out_features, "states": out_states, "model_bodies": out_bodies, "names": kept_of(names.as_slice(), &names_used),+ "sketches": kept_of(sketches.as_slice(), &sketches_used),+ });+ let kept: Vec<usize> = (0..self.bodies.len()).filter(|i| kernel_used.get(*i) == Some(&true)).collect();+ let bodies = kept.iter().filter_map(|i| self.bodies.get(*i).cloned()).collect();+ Some((SavedModel { records, bodies }, kept, used))+ }}impl Model {/// The model a design file kept for `doc` ([`Model::saved`]), taken as `doc`'s evaluation:- /// every feature's result as saved, nothing evaluated. Refused (an error) unless every- /// feature's fingerprint is the one `doc` gives it now, and every record is well formed.+ /// every feature's result as saved, nothing evaluated but the features whose state the file+ /// did not keep ([`SavedModel::thinned`]). Refused (an error) unless every feature's+ /// fingerprint is the one `doc` gives it now, and every record is well formed.pub fn adopt(doc: &Document, saved: &SavedModel) -> Result<Model> {let states = saved.states()?;let records = &saved.records;@@ -381,16 +533,24 @@ impl Model {let step_digests = StepDigests::of(doc, &StepDigests::default());let marker = doc.marker.unwrap_or(usize::MAX);let ctx = context_digest(doc, &vals);- let mut cache = EvalCache::default();let mut before = Arc::new(ModelState::default());+ // Whether `before` is the state before the feature: one the file left out only stands in.+ let mut exact = true;let mut prev = 0;let mut results = Vec::with_capacity(features.len());for (i, (f, r)) in doc.features.iter().zip(features).enumerate() {- prev = chain_fingerprint(doc, &vals, f, prev, i >= marker, &step_digests, Some(&before));- if r.get("id").and_then(Json::as_u64) != Some(f.id) || unhex(r.get("fingerprint").unwrap_or(&Json::Null))? != prev {+ let saved = unhex(r.get("fingerprint").unwrap_or(&Json::Null))?;+ // A fingerprint reads the state before its feature (where the bodies it takes lie).+ // After a state the file left out, the saved one is taken: `evaluate` works that state+ // out, checks the fingerprints after it, and evaluates again from one that differs.+ prev = if exact { chain_fingerprint(doc, &vals, f, prev, i >= marker, &step_digests, Some(&before)) } else { saved };+ if r.get("id").and_then(Json::as_u64) != Some(f.id) || saved != prev {return Err(bad("saved model: the document changed"));}let ms = r.get("ms").and_then(Json::as_f64).filter(|ms| ms.is_finite()).ok_or_else(|| bad("saved model: time"))?;+ // A file without room for every state keeps some features without one (#3220).+ let state =+ r.get("state").map(|s| states.get(index(Some(s), states.len())?).cloned().ok_or_else(|| bad("saved model: state"))).transpose()?;let result = FeatureResult {id: f.id,name: f.name.clone(),@@ -404,27 +564,48 @@ impl Model {skipped: r.get("skipped").and_then(Json::as_bool).ok_or_else(|| bad("saved model: skipped"))?,stale: false,fingerprint: prev,- state: states.get(index(r.get("state"), states.len())?).cloned().ok_or_else(|| bad("saved model: state"))?,+ unkept: state.is_none(),+ state: state.unwrap_or_else(|| before.clone()),};- // Each result where an evaluation would have put it, so an edit undone (or set back)- // finds it again rather than evaluating the feature anew.if !result.skipped {- let local = fingerprint(0, f, &vals, false, &step_digests) ^ placement_digest(doc, f, Some(&before));+ exact = !result.unkept;+ before = result.state.clone();+ }+ results.push(result);+ }+ let mut model = Model { results, param_errors, step_digests, ..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+ // before it: nothing else in the model is missing then.+ model.evaluate(doc);+ log::info!(+ "the saved model kept the states of {} of {} features: {} evaluated again",+ model.results.len().saturating_sub(unkept),+ model.results.len(),+ model.last_recomputed+ );+ }+ // Each result where an evaluation would have put it, so an edit undone (or set back)+ // finds it again rather than evaluating the feature anew.+ let mut before = Arc::new(ModelState::default());+ if let Ok(mut cache) = model.cache.lock() {+ for (f, r) in doc.features.iter().zip(&model.results).filter(|(_, r)| !r.skipped && r.error.is_none()) {+ let local = fingerprint(0, f, &vals, false, &model.step_digests) ^ placement_digest(doc, f, Some(&before));cache.put(- cache_key(f, prev, local, ctx, &before),+ cache_key(f, r.fingerprint, local, ctx, &before),CachedEval {error: None,- warning: result.warning.clone(),- boolean_diagnostics: result.boolean_diagnostics.clone(),- ms,- bytes: result.state.retained_bytes(),- state: result.state.clone(),+ warning: r.warning.clone(),+ boolean_diagnostics: r.boolean_diagnostics.clone(),+ ms: r.ms,+ bytes: r.state.retained_bytes(),+ state: r.state.clone(),},);- before = result.state.clone();+ before = r.state.clone();}- results.push(result);}- Ok(Model { results, param_errors, step_digests, cache: Arc::new(std::sync::Mutex::new(cache)), ..Model::default() })+ Ok(model)}}diff --git a/crates/io/src/design.rs b/crates/io/src/design.rsindex 139c637bfd..c0e7847b93 100644--- a/crates/io/src/design.rs+++ b/crates/io/src/design.rs@@ -92,12 +92,17 @@ impl PackageWriter {/// Would `entries` more optional parts of `extra` bytes, stored uncompressed, still keep/// the file within `budget` and its expanded size within the reader's budget?fn room(&self, entries: usize, extra: usize, budget: usize) -> bool {+ self.names.len().saturating_add(entries) <= MAX_ENTRIES && extra <= self.space(entries, budget)+ }+ /// The bytes `entries` more optional parts may hold together ([`PackageWriter::room`]).+ fn space(&self, entries: usize, budget: usize) -> usize {+ if self.names.len().saturating_add(entries) > MAX_ENTRIES {+ return 0;+ }// The bytes written so far, plus what the open compressed part may still hold back.let written = self.zip.get_ref().map_or(usize::MAX, |c| c.get_ref().len()).saturating_add(1 << 20);let directory = self.names.len().saturating_add(entries).saturating_mul(256).saturating_add(65_536);- self.names.len().saturating_add(entries) <= MAX_ENTRIES- && written.saturating_add(extra).saturating_add(directory) <= budget- && self.expanded.saturating_add(extra) <= MAX_EXPANDED+ budget.saturating_sub(written.saturating_add(directory)).min(MAX_EXPANDED.saturating_sub(self.expanded))}fn blob(&mut self, bytes: &[u8], extension: &str, compressed: bool) -> Result<Value> {self.resolved =@@ -269,15 +274,9 @@ fn write_container(let metadata = serde_json::to_vec(&metadata).map_err(invalid)?;writer.part("document.json", &metadata, true)?;writer.part("container.json", &serde_json::to_vec(&json!({"format": VERSION})).map_err(invalid)?, false)?;- // The model cache is optional: one that does not fit the container is left out, never a- // failed save.- let cache = geometry.and_then(|g| native_cache::encode_model(g, &metadata).ok()).filter(|(manifest, data)| {- let fits = writer.room(2, manifest.len().saturating_add(data.len()), budget);- if !fits {- log::info!("the model cache ({} MB) does not fit the design file: saved without it", (manifest.len() + data.len()) >> 20);- }- fits- });+ // The model cache is optional: one that does not fit the container keeps fewer states, or is+ // left out, never a failed save.+ let cache = geometry.and_then(|g| native_cache::encode_model(g, &metadata, writer.space(2, budget)).ok());if let Some((manifest, data)) = cache {let [manifest_entry, payload_entry] = native_cache::ENTRIES;// Deflated whatever the policy: the encoded bodies shrink about fourfold to tenfold, faster@@ -885,6 +884,143 @@ mod tests {assert!(read_design_geometry(&bytes).is_some());}+ /// A saved model of four features (5, 50, 20 and 1 ms) whose states each hold the eight+ /// bodies all of them share and eight of their own (a body each feature replaces). No+ /// document evaluated it.+ fn timeline_model() -> solidcraft_doc::SavedModel {+ let bodies: Vec<_> = (0..40)+ .map(|i| solidcraft_kernel::box_solid(solidcraft_geom::Vec3::ZERO, solidcraft_geom::Vec3::new(10. + f64::from(i), 20., 30.)).unwrap())+ .collect();+ let records: Vec<Value> = (0..40)+ .map(|i| json!({"name": format!("Body{i}"), "feature": 1 + i / 8, "component": 0, "key": "0000000000000001", "names": 0, "body": i}))+ .collect();+ // As runs of consecutive bodies, which the first state's two groups make one of.+ let states: Vec<Value> = (0..4)+ .map(|i| {+ let bodies = if i == 0 { json!([[0, 16]]) } else { json!([[0, 8], [8 * (i + 1), 8]]) };+ json!({+ "bodies": bodies, "sketches": [], "body_counter": 7, "sheets": [], "construct": [], "threads": [],+ "sketch_keys": [], "blend_edges": {}, "fitted": {}, "tapered": {},+ })+ })+ .collect();+ let features: Vec<Value> = [5., 50., 20., 1.]+ .iter()+ .enumerate()+ .map(|(i, ms)| json!({"id": i + 1, "fingerprint": "0000000000000000", "ms": ms, "skipped": false, "state": i}))+ .collect();+ solidcraft_doc::SavedModel {+ records: json!({"features": features, "states": states, "model_bodies": records, "names": [{"faces": [], "info": []}], "sketches": []}),+ bodies,+ }+ }++ /// Which features keep their state in `model`.+ fn kept_states(model: &Value) -> Vec<bool> {+ model["features"].as_array().unwrap().iter().map(|f| f.get("state").is_some()).collect()+ }++ /// Every body a megabyte, so the records (a few kilobytes) fit in the room left over.+ const BODY: usize = 1 << 20;++ /// A thinned model keeps the final state, then the slowest features' states while the bodies+ /// they add fit, each body counted once however many states hold it (#3220).+ #[test]+ fn a_thinned_model_keeps_the_final_state_then_the_slowest_that_fit() {+ let model = timeline_model();+ let pieces: Vec<Vec<(usize, usize)>> = (0..40).map(|i| vec![(i, BODY)]).collect();+ let thinned = |bodies: usize| {+ let budget = bodies * BODY + BODY / 2;+ model.thinned(&pieces, budget).map(|(m, kept, counted)| (kept_states(&m.records), kept, m, counted <= budget)).unwrap()+ };+ let (states, kept, all, within) = thinned(40);+ assert_eq!((states, kept.len(), within), (vec![true; 4], 40, true));+ assert_eq!(all.records, model.records);+ // The final state and the slowest other (50 ms): the shared bodies count once, else+ // these two states would need 32 bodies' room.+ for bodies in [24, 31] {+ let (states, kept, two, _) = thinned(bodies);+ assert_eq!(states, vec![false, true, false, true], "room for {bodies} bodies");+ assert_eq!(kept, (0..8).chain(16..24).chain(32..40).collect::<Vec<_>>());+ assert_eq!(two.records["model_bodies"].as_array().unwrap().len(), 24);+ let last = two.final_state().unwrap();+ assert_eq!(+ last.bodies.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(),+ (0..8).chain(32..40).map(|i| format!("Body{i}")).collect::<Vec<_>>()+ );+ assert_eq!(last.body_counter, 7);+ }+ assert_eq!(thinned(32).0, vec![false, true, true, true]);+ // The final state only: within the budget, then kept over it (nothing smaller is left).+ for (bodies, within) in [(16, true), (23, true), (15, false)] {+ let (states, kept, one, fits) = thinned(bodies);+ assert_eq!((states, fits), (vec![false, false, false, true], within), "room for {bodies} bodies");+ assert_eq!(kept, (0..8).chain(32..40).collect::<Vec<_>>());+ assert_eq!(+ one.records["states"],+ json!([{+ "bodies": [[0, 16]], "sketches": [], "body_counter": 7, "sheets": [], "construct": [], "threads": [],+ "sketch_keys": [], "blend_edges": {}, "fitted": {}, "tapered": {},+ }])+ );+ }+ }++ /// A model cache too big for the file keeps fewer states rather than none (#3220): the final+ /// state and as many of the slowest others as fit, then the final state only, and nothing+ /// only when not even that fits.+ #[test]+ fn a_model_cache_too_big_for_the_file_keeps_fewer_states() {+ let model = timeline_model();+ let document = b"{}";+ let states = |space| {+ let (manifest, payload) = native_cache::encode_model(&model, document, space).ok()?;+ assert!(manifest.len() + payload.len() <= space);+ Some(kept_states(&serde_json::from_slice::<Value>(&manifest).unwrap()["model"]))+ };+ // The cache of the states room for so many bodies picks, at its own size.+ let pieces: Vec<Vec<(usize, usize)>> = (0..40).map(|i| vec![(i, BODY)]).collect();+ let cache = |bodies: usize| {+ let (thin, _, _) = model.thinned(&pieces, bodies * BODY + BODY / 2).unwrap();+ let (manifest, payload) = native_cache::encode_model(&thin, document, usize::MAX).unwrap();+ (manifest.len(), payload.len())+ };+ let encoded = |i: usize| solidcraft_kernel::encode_native_body(&model.bodies[i]).unwrap().len();+ // What a state's own bodies add: more than the records of the caches below, so the sizes+ // below pick one set of states each.+ let own = (8..40).step_by(8).map(|s| (s..s + 8).map(encoded).sum::<usize>()).min().unwrap();+ let (all, two, one) = (cache(40), cache(24), cache(16));+ assert!(own > two.0, "a state's bodies ({own} bytes) outweigh the records ({} bytes)", two.0);+ assert_eq!(states(all.0 + all.1), Some(vec![true; 4]));+ assert_eq!(states(all.0 + all.1 - 1), Some(vec![false, true, true, true]), "the fastest left out first");+ assert_eq!(states(two.0 + two.1), Some(vec![false, true, false, true]));+ assert_eq!(states(one.0 + one.1), Some(vec![false, false, false, true]));+ assert_eq!(states(one.0 + one.1 - 1), None);+ }++ /// A model whose bodies are all one part stores it once: its records, not its bodies, fill the+ /// room. When those of every state do not fit, the final state is still kept if it fits.+ #[test]+ fn a_model_cache_of_records_too_big_for_the_file_keeps_the_final_state() {+ let mut model = timeline_model();+ let part = model.bodies[0].clone();+ model.bodies.iter_mut().for_each(|b| *b = part.clone());+ let document = b"{}";+ let size = |m: &solidcraft_doc::SavedModel| {+ let (manifest, payload) = native_cache::encode_model(m, document, usize::MAX).unwrap();+ (manifest.len() + payload.len(), serde_json::from_slice::<Value>(&manifest).unwrap()["slices"].as_array().unwrap().len())+ };+ let pieces: Vec<Vec<(usize, usize)>> = (0..40).map(|i| vec![(i, BODY)]).collect();+ let (last, _, _) = model.thinned(&pieces, 16 * BODY + BODY / 2).unwrap();+ let ((all, slices), (one, _)) = (size(&model), size(&last));+ assert_eq!(slices, 1, "the part stored once");+ // Room for the final state's cache and a little more, not for the records of all.+ let space = one + 256;+ assert!(all > space);+ let (manifest, _) = native_cache::encode_model(&model, document, space).unwrap();+ assert_eq!(kept_states(&serde_json::from_slice::<Value>(&manifest).unwrap()["model"]), vec![false, false, false, true]);+ }+#[test]fn native_cache_mismatch_is_only_a_cache_miss() {let doc = document();diff --git a/crates/io/src/design/native_cache.rs b/crates/io/src/design/native_cache.rsindex 7005349f0f..1701d6729c 100644--- a/crates/io/src/design/native_cache.rs+++ b/crates/io/src/design/native_cache.rs@@ -5,7 +5,7 @@use super::*;use solidcraft_doc::{ModelState, SavedModel};-const FORMAT: &str = "solidcraft-model-cache/2";+const FORMAT: &str = "solidcraft-model-cache/3";const PRODUCER: &str = "solidcraft-truck-adapter/3";const MANIFEST: &str = "cache/model.json";const PAYLOAD: &str = "cache/bodies.bin";@@ -26,61 +26,168 @@ fn matrix(t: &[[f64; 4]; 4]) -> Vec<f64> {t.iter().flatten().copied().collect()}-/// Encode a saved model. Identical bodies (the same part placed many times) are stored once; a-/// placed copy of a part records the part and its matrix, so it shows that part's display as it-/// did before saving.-pub(super) fn encode_model(model: &SavedModel, document: &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {- if model.bodies.is_empty() || model.bodies.len() > MAX_RECORDS {- return Err(invalid("cached body count"));- }- // What to encode: every body, and the part every placed copy shows.- let mut shares: Vec<solidcraft_kernel::DisplayShare> = Vec::new();- let mut share_index = std::collections::HashMap::new();- for b in &model.bodies {- if let Some((share, _)) = b.display_share() {- share_index.entry(share.id()).or_insert_with(|| {- shares.push(share.clone());- shares.len() - 1- });+/// Encode a saved model in `space` bytes (manifest and payload together). Identical bodies (the+/// same part placed many times) are stored once; a placed copy of a part records the part and its+/// matrix, so it shows that part's display as it did before saving. A model too big for `space`+/// keeps fewer states, then its final state only ([`SavedModel::thinned`], #3220); an error when+/// not even that fits.+pub(super) fn encode_model(model: &SavedModel, document: &[u8], space: usize) -> Result<(Vec<u8>, Vec<u8>)> {+ let encoded = Encoded::of(model)?;+ let total = encoded.slices.iter().fold(0usize, |n, s| n.saturating_add(s.len()));+ let fits = |manifest: &[u8], payload: &[u8]| manifest.len() <= MAX_MANIFEST && manifest.len().saturating_add(payload.len()) <= space;+ if total <= space {+ let every: Vec<usize> = (0..model.bodies.len()).collect();+ if let Ok((manifest, data)) = encoded.cache(&model.records, &every, document)+ && fits(&manifest, &data)+ {+ return Ok((manifest, data));}}- let bodies: Vec<&solidcraft_kernel::Body> = model.bodies.iter().chain(shares.iter().map(|s| s.original())).collect();- let encoded = solidcraft_kernel::map_on_threads(&bodies, 16, |b| solidcraft_kernel::encode_native_body(b).ok());- let mut data = Vec::new();- let mut slices = Vec::new();- let mut by_digest = std::collections::HashMap::new();- let mut index = Vec::with_capacity(encoded.len());- for bytes in encoded {- let bytes = bytes.flatten().ok_or_else(|| invalid("body not stored exactly"))?;- let next = slices.len();- let i = *by_digest.entry(Sha256::digest(&bytes)).or_insert(next);- if i == next {- if data.len().saturating_add(bytes.len()) > MAX_DESIGN_BYTES || slices.len() >= MAX_UNIQUE {- return Err(invalid("model cache size"));+ // Fewer states. The bodies are encoded already: a state costs the slices it adds.+ let size = |s: &usize| encoded.slices.get(*s).map_or(0, Vec::len);+ let pieces: Vec<Vec<(usize, usize)>> = encoded+ .bodies+ .iter()+ .map(|(s, placed)| std::iter::once(s).chain(placed.as_ref().and_then(|(part, _)| encoded.parts.get(*part))).map(|s| (*s, size(s))).collect())+ .collect();+ let mut budget = space.min(MAX_DESIGN_BYTES);+ for _ in 0..16 {+ let Some((thin, kept, counted)) = model.thinned(&pieces, budget) else { break };+ // Only the final state, which is kept whatever it costs: nothing smaller is left to try. What+ // it counted is about what its cache holds, so over `space` it does not fit.+ let smallest = counted > budget;+ if smallest && counted > space {+ break;+ }+ let Ok((manifest, data)) = encoded.cache(&thin.records, &kept, document) else {+ if smallest {+ break;}- slices.push(json!([data.len(), bytes.len()]));- data.extend(bytes);+ budget = counted / 2;+ continue;+ };+ if fits(&manifest, &data) {+ let features = thin.records.get("features").and_then(Value::as_array).map_or(&[][..], Vec::as_slice);+ log::info!(+ "the model cache ({} MB) does not fit the design file: saved the states of {} of {} features ({} MB), opening evaluates the others again",+ total >> 20,+ features.iter().filter(|f| f.get("state").is_some()).count(),+ features.len(),+ manifest.len().saturating_add(data.len()) >> 20+ );+ return Ok((manifest, data));}- index.push(i);+ if smallest {+ break;+ }+ // What the choice did not count (the bodies' table, the slices) took the room: choose again+ // within that much less than it counted, so each try keeps less.+ let over = manifest.len().saturating_add(data.len()).saturating_sub(space).max(manifest.len().saturating_sub(MAX_MANIFEST));+ budget = counted.saturating_sub(over).saturating_sub(1);}- let (body_index, share_body) = index.split_at(model.bodies.len());- let mut table = Vec::with_capacity(model.bodies.len());- for (b, i) in model.bodies.iter().zip(body_index) {- table.push(match b.display_share() {- Some((share, t)) => json!([i, share_index.get(&share.id()).ok_or_else(|| invalid("display share"))?, matrix(&t)]),- None => json!([i]),- });+ log::info!("the model cache ({} MB) does not fit the design file: saved without it", total >> 20);+ Err(invalid("model cache size"))+}++/// A model's bodies, each encoded once and identical ones stored once (keyed by the SHA-256 of+/// their encoding), in the order a cache of the whole model stores them: every body, then the part+/// every placed copy shows.+struct Encoded {+ /// Each stored body's encoding (kept apart: only what a cache keeps is copied into its payload).+ slices: Vec<Vec<u8>>,+ /// Each model body's slice, with the part (its index in `parts`) and the matrix of a placed copy.+ bodies: Vec<(usize, Option<(usize, [[f64; 4]; 4])>)>,+ /// Each placed part's slice.+ parts: Vec<usize>,+}++impl Encoded {+ fn of(model: &SavedModel) -> Result<Self> {+ // What to encode: every body, and the part every placed copy shows.+ let mut shares: Vec<solidcraft_kernel::DisplayShare> = Vec::new();+ let mut share_index = std::collections::HashMap::new();+ let mut placed = Vec::with_capacity(model.bodies.len());+ for b in &model.bodies {+ placed.push(b.display_share().map(|(share, t)| {+ let part = *share_index.entry(share.id()).or_insert_with(|| {+ shares.push(share.clone());+ shares.len() - 1+ });+ (part, t)+ }));+ }+ let bodies: Vec<&solidcraft_kernel::Body> = model.bodies.iter().chain(shares.iter().map(|s| s.original())).collect();+ let encoded = solidcraft_kernel::map_on_threads(&bodies, 16, |b| solidcraft_kernel::encode_native_body(b).ok());+ let mut slices = Vec::new();+ let mut by_digest = std::collections::HashMap::new();+ let mut index = Vec::with_capacity(encoded.len());+ for bytes in encoded {+ let bytes = bytes.flatten().ok_or_else(|| invalid("body not stored exactly"))?;+ let next = slices.len();+ let i = *by_digest.entry(Sha256::digest(&bytes)).or_insert(next);+ if i == next {+ slices.push(bytes);+ }+ index.push(i);+ }+ let (body_slices, part_slices) = index.split_at_checked(model.bodies.len()).ok_or_else(|| invalid("cached body count"))?;+ Ok(Encoded { slices, bodies: body_slices.iter().copied().zip(placed).collect(), parts: part_slices.to_vec() })}- let manifest = serde_json::to_vec(&json!({- "format": FORMAT, "producer": PRODUCER, "app": env!("CARGO_PKG_VERSION"), "build": build(),- "document": digest(document), "payload": digest(&data),- "slices": slices, "shares": share_body, "bodies": table, "model": model.records,- }))- .map_err(invalid)?;- if manifest.len() > MAX_MANIFEST {- return Err(invalid("model cache manifest size"));++ /// The cache of a model with these `records`, whose bodies are these of the model's (indices+ /// here): its manifest and payload. Refused when it holds too many bodies or its payload is+ /// too large.+ fn cache(&self, records: &Value, bodies: &[usize], document: &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {+ if bodies.is_empty() || bodies.len() > MAX_RECORDS {+ return Err(invalid("cached body count"));+ }+ // The slices stored, in the order first needed: the bodies', then their parts'.+ let mut order = Vec::new();+ let mut renumbered = vec![None; self.slices.len()];+ let mut slice = |s: usize| -> Result<usize> {+ let n = renumbered.get_mut(s).ok_or_else(|| invalid("cached body"))?;+ Ok(*n.get_or_insert_with(|| {+ order.push(s);+ order.len() - 1+ }))+ };+ let mut parts = Vec::new();+ let mut part_index = vec![None; self.parts.len()];+ let mut table = Vec::with_capacity(bodies.len());+ for &b in bodies {+ let (s, placed) = self.bodies.get(b).ok_or_else(|| invalid("cached body"))?;+ let s = slice(*s)?;+ table.push(match placed {+ Some((part, t)) => {+ let p = *part_index.get_mut(*part).ok_or_else(|| invalid("display share"))?.get_or_insert_with(|| {+ parts.push(*part);+ parts.len() - 1+ });+ json!([s, p, matrix(t)])+ }+ None => json!([s]),+ });+ }+ let shares = parts.iter().map(|p| slice(*self.parts.get(*p).ok_or_else(|| invalid("display share"))?)).collect::<Result<Vec<_>>>()?;+ let stored = order.iter().map(|s| self.slices.get(*s).ok_or_else(|| invalid("cached body"))).collect::<Result<Vec<_>>>()?;+ let length = stored.iter().fold(0usize, |n, bytes| n.saturating_add(bytes.len()));+ if length > MAX_DESIGN_BYTES || stored.len() > MAX_UNIQUE {+ return Err(invalid("model cache size"));+ }+ let mut data = Vec::with_capacity(length);+ let mut slices = Vec::with_capacity(stored.len());+ for bytes in stored {+ slices.push(json!([data.len(), bytes.len()]));+ data.extend_from_slice(bytes);+ }+ let manifest = serde_json::to_vec(&json!({+ "format": FORMAT, "producer": PRODUCER, "app": env!("CARGO_PKG_VERSION"), "build": build(),+ "document": digest(document), "payload": digest(&data),+ "slices": slices, "shares": shares, "bodies": table, "model": records,+ }))+ .map_err(invalid)?;+ Ok((manifest, data))}- Ok((manifest, data))}/// The final state of the model a design keeps, when this build computed it for exactly thisdiff --git a/docs/design-container.md b/docs/design-container.mdindex c435fdc587..e4e8c9d848 100644--- a/docs/design-container.md+++ b/docs/design-container.md@@ -119,8 +119,9 @@ Engine Save/Save As write the evaluated model with the design by defaultcarry it. Saving never forces placement, evaluation or tessellation: the model isthe session's own evaluation, and only when it is the evaluation of the documentbeing saved (`Model::is_current`). An active sketch, uncaptured moves, feature-errors, mesh bodies or exceeded budgets leave the cache out; the design saves as-before.+errors or mesh bodies leave the cache out; the design saves as before. A cache+over its budgets keeps fewer states (below) and is left out only when not even+the final state fits.The model is the whole evaluation: every feature's result (warning, booleandiagnostics, whether it was skipped, its fingerprint) and the state after it@@ -146,7 +147,7 @@ SHA-256 of their encoding), and a placed copy of a repeated part (an instance fra STEP assembly) records the part and its matrix, so it shows that part's displayagain instead of being meshed on its own.-`cache/model.json` records `solidcraft-model-cache/2`, the producer revision+`cache/model.json` records `solidcraft-model-cache/3`, the producer revision`solidcraft-truck-adapter/3`, the application version, the build (source commit,CPU architecture and OS), the SHA-256 of the exact `document.json` (whose blobreferences pin every STEP, mesh and image payload) and of `cache/bodies.bin`, the@@ -159,9 +160,20 @@ The fixed budgets of earlier caches (4,096 bodies, 100,000 faces, 64 MiB) scalewith the design now: up to 200,000 body records, 100,000 distinct bodies, a 32 MiBmanifest and a payload within the container's part budget (256 MiB), leaving roomfor the document. Individual bodies keep the codec's own limits. The archive-wide-budgets (256 MiB per part, 512 MiB expanded, 10,000 entries) are unchanged, and the-cache is left out when it would push the container near them. Decoding runs under-`kernel::guard` and is linear in the payload's bytes.+budgets (256 MiB per part, 512 MiB expanded, 10,000 entries) are unchanged.+Decoding runs under `kernel::guard` and is linear in the payload's bytes.++A model whose cache would push the container past them keeps fewer states+(`SavedModel::thinned`, #3220): the final state (what the design shows), then the+other states, the slowest feature's first (the evaluations opening would otherwise+repeat for longest), each while what it adds still fits: the bodies no state kept+so far holds (a body is stored once however many states hold it) and the records+of the state, those bodies, their names and sketches. When the rest of the+manifest (the bodies' table, the slices) then leaves too little room, the choice+is made again within that much less, and the final state alone is always tried.+A feature whose state is left out records none. The cache is left out (and the+save logs it) only when not even the final state fits; a thinned cache logs how+many features kept their state.### Opening from the model@@ -174,9 +186,18 @@ evaluates from the first feature it changes, as after any evaluation: a featureappended or edited at the end evaluates from the saved final state, an edit tofeature k from the saved state before k. Moving the timeline marker, undo and redoreuse the saved results whose fingerprints come back. `SOLIDCRAFT_NO_MODEL_CACHE`-set evaluates anyway. Any failure (a key or fingerprint mismatch, a malformed-record, a body that does not decode) is a miss: the design is evaluated from its-timeline as before, and only that.+set evaluates anyway.++A thinned cache is taken the same way, and the features whose state it left out+are evaluated while opening, each from the state before it (kept or just+evaluated); the states it kept after them stand. Opening then costs the+evaluations of those features only, and the model is whole afterwards: nothing+else in the application sees a missing state. Should one of them fail now, the+features after it are evaluated too, as a full evaluation would.++Any failure (a key or fingerprint mismatch, a malformed record, a body that does+not decode) is a miss: the design is evaluated from its timeline as before, and+only that.This replaces the earlier rule that a cache never supplies evaluated sessionstate. It is safe because the cache is the result of evaluating exactly this