Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Save: write the model cache manifest without copying the model's records (#10419)

kaltenbrunnermarkus7e701aabc132
diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rs
index 95ab451494..233477ceb6 100644
--- a/crates/doc/src/model_cache.rs
+++ b/crates/doc/src/model_cache.rs
@@ -223,11 +223,15 @@ impl Writer {
}
fn sheet(&mut self, sheet: &crate::sheet::SheetBody) -> Option<usize> {
- let record = serde_json::to_value(sheet).ok()?;
- let key = record.to_string();
+ // Keyed by the sheet written as text, straight from the sheet: every state asks for each
+ // of its sheets, and building the record (a JSON tree) each time only to find it written
+ // already took most of a sheet-metal design's save (906 states, 300 sheets: 0.8 s). Two
+ // sheets are the same text exactly when they are the same record.
+ let key = serde_json::to_string(sheet).ok()?;
if let Some(i) = self.sheet_index.get(&key) {
return Some(*i);
}
+ let record = serde_json::to_value(sheet).ok()?;
self.sheets.push(record);
self.sheet_index.insert(key, self.sheets.len() - 1);
Some(self.sheets.len() - 1)
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index d3dc965be0..95100ebd4f 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -1425,6 +1425,41 @@ mod tests {
assert!(d.rejected.is_empty());
}
+ /// The model a save keeps writes each distinct sheet-metal body once, and every state names
+ /// the records of exactly the sheets it holds (found by the sheet's text, not by building its
+ /// record again for every state, which took most of a large sheet-metal design's save).
+ #[test]
+ fn a_saved_model_writes_each_sheet_once_for_the_states_that_hold_it() {
+ let mut s = Session::new(Document::new("Sheets"));
+ let sheet_rule = json!({"name": "AL2", "thickness": "2 mm", "k_factor": "0.5", "bend_radius": "1 mm", "active": true});
+ s.execute("sheet.manage_rules", &sheet_rule).unwrap();
+ for (i, x) in [0.0, 200.0, 400.0].into_iter().enumerate() {
+ s.execute("sketch.create", &json!({"plane": "XY", "name": format!("Base{i}")})).unwrap();
+ s.execute("sketch.rectangle.two_point", &json!({"p0": [x, 0], "p1": [x + 150.0, 100]})).unwrap();
+ s.execute("sketch.finish", &json!({})).unwrap();
+ s.execute("sheet.flange", &json!({"sketch": format!("Base{i}")})).unwrap();
+ s.execute("sheet.flange", &json!({"edges": [[x + 75.0, 0, 2]], "height": 20})).unwrap();
+ }
+ let saved = saved_geometry(&s, &s.doc).unwrap();
+ let records = &saved.records;
+ let sheets = records["sheets"].as_array().unwrap();
+ let texts: std::collections::HashSet<String> = sheets.iter().map(Value::to_string).collect();
+ assert_eq!(texts.len(), sheets.len(), "each sheet once");
+ let mut held = std::collections::HashSet::new();
+ for (r, feature) in s.model.results.iter().zip(records["features"].as_array().unwrap()) {
+ let state = &records["states"][feature["state"].as_u64().unwrap() as usize];
+ let named = state["sheets"].as_array().unwrap();
+ assert_eq!(named.len(), r.state.sheets.len());
+ for (i, sheet) in named.iter().zip(&r.state.sheets) {
+ let written = &sheets[i.as_u64().unwrap() as usize];
+ assert_eq!(*written, serde_json::to_value(sheet).unwrap(), "{}: the record of its own sheet", r.name);
+ held.insert(written.to_string());
+ }
+ }
+ assert_eq!(held, texts, "every record written is one a state holds");
+ assert!(sheets.len() >= 6, "each part's base, then with its flange: {}", sheets.len());
+ }
+
/// A design whose saved model would give a body back with other topology opens with the
/// bodies it was saved with. A pattern copy cut by an automatic extrude came back from the
/// native codec with two loose vertices more (10 faces, 18 edges, 12 vertices instead of 10);
diff --git a/crates/io/src/design.rs b/crates/io/src/design.rs
index 683ed07c9d..3a293b8cb5 100644
--- a/crates/io/src/design.rs
+++ b/crates/io/src/design.rs
@@ -1190,6 +1190,25 @@ mod tests {
}
}
+ /// The model cache's manifest, written straight from the model's records (not copied into a
+ /// JSON tree first), is byte for byte what writing it as a tree wrote: the same keys in the
+ /// same (sorted) order, the same numbers.
+ #[test]
+ fn the_model_cache_manifest_is_what_a_json_tree_writes() {
+ use solidcraft_geom::Vec3;
+ let part = solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();
+ let share = solidcraft_kernel::DisplayShare::new(part.clone());
+ let t = [[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [50.5, -0.25, 1e-7, 1.]];
+ let moved = solidcraft_kernel::transform(&part, Vec3::new(50.5, -0.25, 1e-7), Vec3::ZERO, Vec3::Z, 0.).unwrap();
+ let model = saved_model(vec![part.clone(), moved.with_display_share(&share, t)]);
+ let bytes = write_design_container_with_cache(&document(), DesignCompression::Fast, None, Some(&model)).unwrap();
+ let manifest = &parts(&bytes)["cache/model.json"];
+ let tree: Value = serde_json::from_slice(manifest).unwrap();
+ assert_eq!(serde_json::to_vec(&tree).unwrap(), *manifest);
+ assert_eq!(tree["model"], model.records);
+ assert_eq!(tree.as_object().unwrap().len(), 11, "{:?}", tree.as_object().unwrap().keys().collect::<Vec<_>>());
+ }
+
/// #9170: a mesh body (an imported STL) is kept in the model cache with the rest of the
/// model, as its own triangles, colour and paint. One mesh body left the whole cache out, so
/// opening the design evaluated every feature again.
diff --git a/crates/io/src/design/native_cache.rs b/crates/io/src/design/native_cache.rs
index 72b82b732f..9f4c2b1970 100644
--- a/crates/io/src/design/native_cache.rs
+++ b/crates/io/src/design/native_cache.rs
@@ -289,16 +289,44 @@ impl Encoded {
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(),
- "evaluation": evaluation(), "document": digest(document), "payload": digest(&data),
- "slices": slices, "shares": shares, "bodies": table, "model": records,
- }))
+ let manifest = serde_json::to_vec(&Manifest {
+ app: env!("CARGO_PKG_VERSION"),
+ bodies: table,
+ build: build(),
+ document: digest(document),
+ evaluation: evaluation(),
+ format: FORMAT,
+ model: records,
+ payload: digest(&data),
+ producer: PRODUCER,
+ shares,
+ slices,
+ })
.map_err(invalid)?;
Ok((manifest, data))
}
}
+/// A model cache's manifest as written: the model's records are written where they are, not
+/// copied into a JSON tree first (copying a large model's records took as long as writing them,
+/// and a cache too big for the file is written again for each try at fewer states). The fields
+/// are in the order a JSON object keeps its keys (sorted), so the manifest is the one a tree
+/// wrote, byte for byte.
+#[derive(serde::Serialize)]
+struct Manifest<'a> {
+ app: &'a str,
+ bodies: Vec<Value>,
+ build: String,
+ document: String,
+ evaluation: String,
+ format: &'a str,
+ model: &'a Value,
+ payload: String,
+ producer: &'a str,
+ shares: Vec<usize>,
+ slices: Vec<Value>,
+}
+
/// The final state of the model a design keeps, when this build's evaluation source computed it
/// for exactly this document. Any failure is a miss, never a document error.
pub fn read_design_geometry(bytes: &[u8]) -> Option<std::sync::Arc<ModelState>> {