* claim: #2678 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * WIP: timeline.dependents shares the evaluation cache (#2678) The check before a delete evaluated the edited design on a fresh model: it recomputed the whole timeline and left nothing for the delete. It now evaluates on a copy of the session's model. Adds Ahead::replies for running such checks off the window thread (the UI part is still to come). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Delete: check what a delete breaks off the window thread (#2678) Both checks a delete makes first (timeline.dependents for the timeline's Delete, the selection.delete dry run for Delete on the selection) evaluate the history after the deleted feature, on the window thread. A part with a slow feature froze the window for as long as everything after it took (5.9 s in the report). They now compute off the window thread like undo and the history marker: within the app's 150 ms wait they carry on at once, otherwise the window says it computes and the delete (or the confirmation) follows when the report is in. A design changed meanwhile is checked again; a second Delete meanwhile is left out. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * ci: run the checks again (the run for 3b94e8e0 was cancelled when the PR left draft) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
This commit is contained in:
@@ -1075,7 +1075,7 @@ fn reorder(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
sort_group_features(&mut next);
|
||||
require_contiguous_groups(&next, cmd)?;
|
||||
// Everything that evaluated before must still evaluate.
|
||||
let mut after = solidcraft_doc::Model::new();
|
||||
let mut after = s.model.clone();
|
||||
after.evaluate(&next);
|
||||
let broken = newly_broken(&s.model, &after);
|
||||
if !broken.is_empty() {
|
||||
@@ -1338,7 +1338,10 @@ fn dependents(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let id = feature_id(s, p.get("feature"), cmd)?;
|
||||
let mut next = (*s.doc).clone();
|
||||
let gone = next.delete_feature(id)?;
|
||||
let mut after = solidcraft_doc::Model::new();
|
||||
// On a copy of the session's model, which shares its evaluation cache (#2678): the features
|
||||
// before this one are reused rather than recomputed, and the delete that usually follows
|
||||
// finds the ones after it already computed.
|
||||
let mut after = s.model.clone();
|
||||
after.evaluate(&next);
|
||||
let names = |ids: &[u64]| -> Vec<String> { ids.iter().filter(|x| **x != id).filter_map(|x| s.doc.feature(*x).map(|f| f.name.clone())).collect() };
|
||||
let broken: Vec<String> = newly_broken(&s.model, &after).into_iter().map(|(n, _)| n).collect();
|
||||
|
||||
@@ -597,6 +597,26 @@ fn edit_refuses_unknown_fields() {
|
||||
assert_eq!(def["combine"], json!(true), "{def}");
|
||||
}
|
||||
|
||||
/// The check before a delete (`timeline.dependents`) evaluates on the session's model, so it
|
||||
/// shares the evaluation cache (#2678): the delete that follows finds the features after the
|
||||
/// deleted one already computed instead of computing them again. (What it reports is covered by
|
||||
/// the timeline tests in `tests.rs`.)
|
||||
#[test]
|
||||
fn the_dependents_check_leaves_the_delete_its_results() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 60, "width": 20, "height": 10, "name": "Base"}));
|
||||
run(&mut s, "solid.box", json!({"corner": [5, 5, 10], "length": 10, "width": 10, "height": 5, "operation": "join", "name": "Boss"}));
|
||||
run(&mut s, "solid.cylinder", json!({"base": [40, 10, -1], "radius": 2, "height": 20, "operation": "cut", "name": "Hole"}));
|
||||
let report = run(&mut s, "timeline.dependents", json!({"feature": "Boss"}));
|
||||
assert_eq!(report, json!({"deleted_with_it": [], "would_fail": []}));
|
||||
let hits = |s: &Session| s.model.cache.lock().map(|c| c.hits).unwrap_or(0);
|
||||
let before = hits(&s);
|
||||
run(&mut s, "timeline.delete", json!({"features": ["Boss"]}));
|
||||
assert!(hits(&s) > before, "the delete takes the hole the check computed from the cache");
|
||||
let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((volume - (12000.0 - std::f64::consts::PI * 4.0 * 10.0)).abs() < 1.0, "{volume}");
|
||||
}
|
||||
|
||||
fn suppressed(s: &Session, name: &str) -> bool {
|
||||
s.doc.find_feature(name).unwrap().suppressed
|
||||
}
|
||||
|
||||
@@ -165,6 +165,13 @@ impl Ahead {
|
||||
pub fn evaluate(self, commands: &[(String, Value)]) -> Result<()> {
|
||||
self.0.preview_in_place(commands).map(|_| ())
|
||||
}
|
||||
|
||||
/// Run `commands` one after another, each reply or error in turn (what they evaluate stays
|
||||
/// in the shared evaluation cache): the checks a front end makes before a command, such as
|
||||
/// what a delete takes with it (#2678), computed off its window thread.
|
||||
pub fn replies(mut self, commands: &[(String, Value)]) -> Vec<Result<Value>> {
|
||||
commands.iter().map(|(id, params)| self.0.execute(id, params)).collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// What some commands would make, evaluated on a scratch copy of a session
|
||||
|
||||
@@ -11,6 +11,12 @@
|
||||
//! its features in the cache. Commands asked for meanwhile wait their turn; a marker moved again
|
||||
//! replaces the move still waiting, so a drag computes where it ends rather than every slot it
|
||||
//! crossed.
|
||||
//!
|
||||
//! A delete first checks what it takes with it and what it would make fail (#2678): the
|
||||
//! timeline's Delete asks `timeline.dependents`, Delete on the selection runs `selection.delete`
|
||||
//! as a dry run. Each check evaluates the history after the deleted feature, so it is computed
|
||||
//! the same way ([`DeleteCheck`]): the window goes on while it computes, then the delete runs, or
|
||||
//! the confirmation opens, with the check's results already in the cache.
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
@@ -32,6 +38,54 @@ impl Deferred {
|
||||
}
|
||||
}
|
||||
|
||||
/// A delete's check computing off the window thread: each check command's reply, in order.
|
||||
pub struct DeleteCheck {
|
||||
done: std::sync::mpsc::Receiver<Vec<Result<Value, String>>>,
|
||||
/// When it started (ms).
|
||||
pub(crate) started: f64,
|
||||
then: AfterCheck,
|
||||
/// The design's revision it was computed for: a design changed meanwhile checks again.
|
||||
revision: u64,
|
||||
}
|
||||
|
||||
/// What a delete does once its check is in.
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) enum AfterCheck {
|
||||
/// The timeline's Delete of these features (a `timeline.dependents` report for each).
|
||||
Timeline(Vec<u64>),
|
||||
/// Delete with these `selection.delete` parameters (the report of its dry run).
|
||||
Selection(Value),
|
||||
}
|
||||
|
||||
impl AfterCheck {
|
||||
/// Check again, for the design as it is now.
|
||||
fn restart(self, app: &mut SolveApp) {
|
||||
match self {
|
||||
AfterCheck::Timeline(ids) => {
|
||||
let ids: Vec<u64> = ids.into_iter().filter(|id| app.session.doc.feature(*id).is_some()).collect();
|
||||
if !ids.is_empty() {
|
||||
crate::timeline::delete_features(app, ids);
|
||||
}
|
||||
}
|
||||
AfterCheck::Selection(params) => crate::delete::request(app, params),
|
||||
}
|
||||
}
|
||||
|
||||
/// Carry on with the check's replies.
|
||||
fn finish(self, app: &mut SolveApp, replies: Vec<Result<Value, String>>) {
|
||||
match self {
|
||||
AfterCheck::Timeline(ids) => {
|
||||
let reports: Vec<Value> = replies.into_iter().map(Result::unwrap_or_default).collect();
|
||||
crate::timeline::delete_checked_features(app, ids, &reports);
|
||||
}
|
||||
AfterCheck::Selection(params) => {
|
||||
let report = replies.into_iter().next().unwrap_or_else(|| Err("the delete was not checked".into()));
|
||||
crate::delete::checked(app, params, report);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Commands a later one of the same kind replaces while they wait: where the marker ends is all
|
||||
/// that counts.
|
||||
fn replaced_by_a_later_one(id: &str) -> bool {
|
||||
@@ -59,9 +113,64 @@ impl SolveApp {
|
||||
}
|
||||
}
|
||||
|
||||
/// Since when a command has been computing off the window thread (ms), if one is.
|
||||
/// Since when a command, or a delete's check, has been computing off the window thread (ms),
|
||||
/// if one is.
|
||||
pub fn computing_since(&self) -> Option<f64> {
|
||||
self.deferred.as_ref().map(|d| d.started)
|
||||
let started = [self.deferred.as_ref().map(|d| d.started), self.delete_check.as_ref().map(|c| c.started)];
|
||||
started.into_iter().flatten().reduce(f64::min)
|
||||
}
|
||||
|
||||
/// Run a delete's check `commands` and carry on with `then` once their replies are in: off
|
||||
/// the window thread when it takes longer than the app's wait (see the module notes),
|
||||
/// otherwise right away. A Delete while another delete is being checked is left out.
|
||||
pub(crate) fn check_delete(&mut self, commands: Vec<(String, Value)>, then: AfterCheck) {
|
||||
if self.delete_check.is_some() {
|
||||
return;
|
||||
}
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(wait) = self.apply_off_thread
|
||||
&& !self.file_load.busy()
|
||||
&& self.file_picker.is_none()
|
||||
{
|
||||
let ahead = self.session.ahead();
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
let checks = commands.clone();
|
||||
let spawned = std::thread::Builder::new().name("delete check".into()).spawn(move || {
|
||||
let replies = ahead.replies(&checks).into_iter().map(|r| r.map_err(|e| e.to_string())).collect();
|
||||
let _ = tx.send(replies);
|
||||
});
|
||||
if spawned.is_ok() {
|
||||
let check = DeleteCheck { done: rx, started: crate::now_ms(), then, revision: self.session.revision };
|
||||
// As with the history's commands, zero always leaves it for a later frame.
|
||||
match (wait.is_zero(), check.done.recv_timeout(wait)) {
|
||||
(false, Ok(replies)) => check.then.finish(self, replies),
|
||||
_ => self.delete_check = Some(check),
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
let replies = commands.iter().map(|(id, params)| self.session.execute(id, params).map_err(|e| e.to_string())).collect();
|
||||
then.finish(self, replies);
|
||||
}
|
||||
|
||||
/// Each frame: a delete whose check is in carries on (checked again when the design changed
|
||||
/// meanwhile).
|
||||
pub(crate) fn poll_delete_check(&mut self, ctx: &egui::Context) {
|
||||
let Some(check) = &self.delete_check else { return };
|
||||
let replies = match check.done.try_recv() {
|
||||
Err(std::sync::mpsc::TryRecvError::Empty) => {
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(100));
|
||||
return;
|
||||
}
|
||||
Err(std::sync::mpsc::TryRecvError::Disconnected) => None,
|
||||
Ok(replies) => Some(replies),
|
||||
};
|
||||
let Some(check) = self.delete_check.take() else { return };
|
||||
match replies {
|
||||
None => self.set_status("the delete could not be checked", true),
|
||||
Some(_) if check.revision != self.session.revision => check.then.restart(self),
|
||||
Some(replies) => check.then.finish(self, replies),
|
||||
}
|
||||
}
|
||||
|
||||
/// Each frame: a command whose evaluation is in runs, then the next one waiting starts.
|
||||
|
||||
@@ -50,17 +50,23 @@ pub fn delete_selection(app: &mut SolveApp) {
|
||||
}
|
||||
|
||||
/// Delete `params` (as `selection.delete` takes them): at once, or after a confirmation when
|
||||
/// other features go with it or would fail.
|
||||
/// other features go with it or would fail. The dry run that finds out evaluates the history
|
||||
/// after what is deleted, so it may compute off the window thread (#2678).
|
||||
pub fn request(app: &mut SolveApp, params: Value) {
|
||||
if is_empty(¶ms) {
|
||||
return;
|
||||
}
|
||||
let mut dry = params.clone();
|
||||
dry["dry_run"] = json!(true);
|
||||
let report = match app.session.execute("selection.delete", &dry) {
|
||||
app.check_delete(vec![("selection.delete".to_string(), dry)], crate::deferred::AfterCheck::Selection(params));
|
||||
}
|
||||
|
||||
/// [`request`] once its dry run's report is in.
|
||||
pub(crate) fn checked(app: &mut SolveApp, params: Value, report: Result<Value, String>) {
|
||||
let report = match report {
|
||||
Ok(r) => r,
|
||||
Err(e) => {
|
||||
app.set_status(e.to_string().replace("selection.delete: ", ""), true);
|
||||
app.set_status(e.replace("selection.delete: ", ""), true);
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -27,7 +27,7 @@ fn block_boss_hole() -> Harness {
|
||||
/// Frames until nothing computes or waits (a few seconds at most).
|
||||
fn until_settled(h: &mut Harness) {
|
||||
for _ in 0..500 {
|
||||
if h.app.deferred.is_none() && h.app.deferred_queue.is_empty() {
|
||||
if h.app.deferred.is_none() && h.app.deferred_queue.is_empty() && h.app.delete_check.is_none() {
|
||||
break;
|
||||
}
|
||||
h.frames(1);
|
||||
@@ -98,3 +98,73 @@ fn a_design_changed_while_a_move_computes_is_computed_again() {
|
||||
assert!(h.app.session.revision > revision, "the move ran after the change");
|
||||
assert_eq!(marker(&h), Some(2));
|
||||
}
|
||||
|
||||
fn feature_ids(h: &Harness) -> Vec<u64> {
|
||||
h.app.session.doc.features.iter().map(|f| f.id).collect()
|
||||
}
|
||||
|
||||
/// Volume of the block with the hole through it, once the boss is deleted.
|
||||
fn block_with_hole() -> f64 {
|
||||
12000.0 - std::f64::consts::PI * 4.0 * 10.0
|
||||
}
|
||||
|
||||
fn volume(h: &mut Harness) -> f64 {
|
||||
h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap()
|
||||
}
|
||||
|
||||
/// The timeline's Delete checks what the delete breaks off the window thread (#2678): the design
|
||||
/// is as it was while it checks, and the feature goes once the check is in.
|
||||
#[test]
|
||||
fn the_timelines_delete_checks_off_the_window_thread() {
|
||||
let mut h = block_boss_hole();
|
||||
let boss = feature_ids(&h)[1];
|
||||
crate::timeline::delete_features(&mut h.app, vec![boss]);
|
||||
assert!(h.app.computing_since().is_some(), "checking");
|
||||
assert!(h.app.session.doc.feature(boss).is_some(), "the design is as it was while it checks");
|
||||
until_settled(&mut h);
|
||||
assert!(h.app.session.doc.feature(boss).is_none(), "deleted once the check is in");
|
||||
assert!(h.app.dialog.is_none(), "nothing breaks, so nothing to confirm");
|
||||
assert!((volume(&mut h) - block_with_hole()).abs() < 1.0);
|
||||
}
|
||||
|
||||
/// Delete on the selection (the Delete key) runs its dry run off the window thread too.
|
||||
#[test]
|
||||
fn delete_on_the_selection_checks_off_the_window_thread() {
|
||||
let mut h = block_boss_hole();
|
||||
let boss = feature_ids(&h)[1];
|
||||
h.app.session.selection = vec![solidcraft_engine::Sel::Feature { id: boss }];
|
||||
let params = crate::delete::selection_params(&h.app);
|
||||
crate::delete::request(&mut h.app, params);
|
||||
assert!(h.app.computing_since().is_some(), "checking");
|
||||
assert!(h.app.session.doc.feature(boss).is_some());
|
||||
until_settled(&mut h);
|
||||
assert!(h.app.session.doc.feature(boss).is_none());
|
||||
assert!(h.app.menu.confirm.is_none());
|
||||
assert!((volume(&mut h) - block_with_hole()).abs() < 1.0);
|
||||
}
|
||||
|
||||
/// A design changed while its delete is checked is checked again before anything is deleted, and
|
||||
/// a second Delete meanwhile is left out.
|
||||
#[test]
|
||||
fn a_design_changed_while_a_delete_is_checked_is_checked_again() {
|
||||
let mut h = block_boss_hole();
|
||||
let ids = feature_ids(&h);
|
||||
crate::timeline::delete_features(&mut h.app, vec![ids[1]]);
|
||||
crate::timeline::delete_features(&mut h.app, vec![ids[2]]);
|
||||
h.app.run("solid.box", json!({"corner": [100, 0, 0], "length": 10, "width": 10, "height": 10})).unwrap();
|
||||
until_settled(&mut h);
|
||||
assert!(h.app.session.doc.feature(ids[1]).is_none(), "the boss is deleted");
|
||||
assert!(h.app.session.doc.feature(ids[2]).is_some(), "the second Delete was left out");
|
||||
assert!((volume(&mut h) - (block_with_hole() + 1000.0)).abs() < 1.0, "the box added meanwhile stays");
|
||||
}
|
||||
|
||||
/// Without a wait (headless use, tests) the check runs in place, as before.
|
||||
#[test]
|
||||
fn without_a_wait_the_delete_checks_in_place() {
|
||||
let mut h = block_boss_hole();
|
||||
h.app.apply_off_thread = None;
|
||||
let boss = feature_ids(&h)[1];
|
||||
crate::timeline::delete_features(&mut h.app, vec![boss]);
|
||||
assert!(h.app.delete_check.is_none());
|
||||
assert!(h.app.session.doc.feature(boss).is_none());
|
||||
}
|
||||
|
||||
@@ -370,6 +370,9 @@ pub struct SolveApp {
|
||||
/// thread, and those asked for meanwhile ([`deferred`]).
|
||||
pub deferred: Option<deferred::Deferred>,
|
||||
pub deferred_queue: Vec<(String, Value)>,
|
||||
/// A delete's check of what it takes with it or breaks, computing off the window thread
|
||||
/// ([`deferred::DeleteCheck`], #2678).
|
||||
pub delete_check: Option<deferred::DeleteCheck>,
|
||||
/// How long OK waits for a feature before computing it off the window thread, saying so;
|
||||
/// `None`: it waits as long as it takes (headless use, tests). The desktop app sets it.
|
||||
pub apply_off_thread: Option<std::time::Duration>,
|
||||
@@ -492,6 +495,7 @@ impl SolveApp {
|
||||
applying: None,
|
||||
deferred: None,
|
||||
deferred_queue: Vec::new(),
|
||||
delete_check: None,
|
||||
apply_off_thread: None,
|
||||
last_command: None,
|
||||
esc_handled: false,
|
||||
@@ -1430,6 +1434,7 @@ impl SolveApp {
|
||||
fn cad_ui(&mut self, ui: &mut egui::Ui, report_input: &mut Option<issue_report::CadInput>) {
|
||||
scenario::clear_handles();
|
||||
self.poll_deferred(ui.ctx());
|
||||
self.poll_delete_check(ui.ctx());
|
||||
toolbar::app_bar(self, ui);
|
||||
issue_report::CadInput::block(self, ui, report_input);
|
||||
file_load::show(self, ui.ctx());
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
pub(crate) use crate::icons::glyphs::transport_glyph;
|
||||
use egui::{Rect, Sense, Stroke, UiBuilder, pos2, vec2};
|
||||
use serde_json::json;
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_engine::doc::{
|
||||
FeatureKind, PlaneRef, SketchId,
|
||||
construct::{AxisDef, PointDef},
|
||||
@@ -150,11 +150,18 @@ pub(crate) fn delete_feature(app: &mut SolveApp, id: u64) {
|
||||
delete_features(app, vec![id]);
|
||||
}
|
||||
|
||||
/// Check what deleting `ids` takes with it or makes fail (off the window thread when that takes a
|
||||
/// while, #2678), then delete them or ask first.
|
||||
pub(crate) fn delete_features(app: &mut SolveApp, ids: Vec<u64>) {
|
||||
let checks = ids.iter().map(|id| ("timeline.dependents".to_string(), json!({ "feature": id }))).collect();
|
||||
app.check_delete(checks, crate::deferred::AfterCheck::Timeline(ids));
|
||||
}
|
||||
|
||||
/// [`delete_features`] once each feature's `timeline.dependents` report is in.
|
||||
pub(crate) fn delete_checked_features(app: &mut SolveApp, ids: Vec<u64>, reports: &[Value]) {
|
||||
let mut with = std::collections::BTreeSet::new();
|
||||
let mut fail = std::collections::BTreeSet::new();
|
||||
for id in &ids {
|
||||
let deps = app.session.execute("timeline.dependents", &json!({ "feature": id })).unwrap_or_default();
|
||||
for deps in reports {
|
||||
for (key, output) in [("deleted_with_it", &mut with), ("would_fail", &mut fail)] {
|
||||
output
|
||||
.extend(deps.get(key).and_then(|value| value.as_array()).into_iter().flatten().filter_map(|value| value.as_str().map(String::from)));
|
||||
|
||||
Reference in New Issue
Block a user