History and parameter changes: the run here takes every result computed ahead (#7002)
A change computed off the window thread ran here with only the results of the evaluation ahead's last evaluate primed. A parameter change evaluates twice (before and after its sketch stores the new solution), so its first evaluate here found nothing to take, and on a design whose states pass the evaluation cache's budget it recomputed the features on the window thread: the window froze for seconds after Computing ended. The run now also takes what the evaluation ahead kept (KeptResults, as an agent's control requests already do).
This commit is contained in:
1 parent
06af6e1107
commit
ffbcdc614c
2 files changed
+60
-13
No files matched your search
@@ -33,6 +33,10 @@ pub struct Deferred {
|
||||
command: (String, Value),
|
||||
/// The design's revision it was computed for: a design changed meanwhile computes it again.
|
||||
revision: u64,
|
||||
/// Every result the evaluation ahead computed, whatever the evaluation cache dropped since,
|
||||
/// for the run here (a parameter change evaluates twice: the first evaluation is not the
|
||||
/// one `evaluated` holds).
|
||||
kept: Option<std::sync::Arc<solidcraft_engine::doc::KeptResults>>,
|
||||
}
|
||||
|
||||
impl Deferred {
|
||||
@@ -53,7 +57,7 @@ enum Start {
|
||||
/// It computes off the window thread.
|
||||
Later(Deferred),
|
||||
/// It runs now, with what was evaluated for it ahead (if anything).
|
||||
Now(Option<solidcraft_engine::Evaluated>),
|
||||
Now(Option<solidcraft_engine::Evaluated>, Option<std::sync::Arc<solidcraft_engine::doc::KeptResults>>),
|
||||
}
|
||||
|
||||
/// A delete's check computing off the window thread: each check command's reply, in order.
|
||||
@@ -127,16 +131,23 @@ impl SolveApp {
|
||||
self.deferred = Some(job);
|
||||
Ok(Value::Null)
|
||||
}
|
||||
Start::Now(evaluated) => self.run_evaluated(id, params, evaluated.as_ref()),
|
||||
Start::Now(evaluated, kept) => self.run_evaluated(id, params, evaluated.as_ref(), kept),
|
||||
}
|
||||
}
|
||||
|
||||
/// Run a command for real, taking the features `evaluated` computed for it ahead.
|
||||
fn run_evaluated(&mut self, id: &str, params: Value, evaluated: Option<&solidcraft_engine::Evaluated>) -> Result<Value, String> {
|
||||
/// Run a command for real, taking the features `evaluated` computed for it ahead, and any
|
||||
/// other result that evaluation `kept`, so the window thread computes none of them again.
|
||||
fn run_evaluated(
|
||||
&mut self,
|
||||
id: &str,
|
||||
params: Value,
|
||||
evaluated: Option<&solidcraft_engine::Evaluated>,
|
||||
kept: Option<std::sync::Arc<solidcraft_engine::doc::KeptResults>>,
|
||||
) -> Result<Value, String> {
|
||||
if let Some(evaluated) = evaluated {
|
||||
self.session.prime(evaluated);
|
||||
}
|
||||
let r = self.run(id, params);
|
||||
let r = self.run_with_kept(kept, |app| app.run(id, params));
|
||||
self.session.unprime();
|
||||
r
|
||||
}
|
||||
@@ -215,7 +226,7 @@ impl SolveApp {
|
||||
// The design changed meanwhile: computed again for the design as it is now.
|
||||
let _ = self.run_heavy(&id, params);
|
||||
} else if !superseded {
|
||||
let _ = self.run_evaluated(&id, params, job.evaluated.flatten().as_ref());
|
||||
let _ = self.run_evaluated(&id, params, job.evaluated.flatten().as_ref(), job.kept);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -238,11 +249,12 @@ impl SolveApp {
|
||||
/// done within the wait.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn begin_deferred(&self, id: &str, params: &Value) -> Start {
|
||||
let Some(wait) = self.apply_off_thread else { return Start::Now(None) };
|
||||
let Some(wait) = self.apply_off_thread else { return Start::Now(None, None) };
|
||||
if self.file_load.busy() || self.file_picker.is_some() {
|
||||
return Start::Now(None);
|
||||
return Start::Now(None, None);
|
||||
}
|
||||
let ahead = self.session.ahead();
|
||||
let kept = ahead.kept();
|
||||
let command = (id.to_string(), params.clone());
|
||||
let commands = vec![command.clone()];
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
@@ -250,22 +262,22 @@ impl SolveApp {
|
||||
let _ = tx.send(ahead.evaluate(&commands).ok());
|
||||
});
|
||||
if spawned.is_err() {
|
||||
return Start::Now(None);
|
||||
return Start::Now(None, None);
|
||||
}
|
||||
// Zero explicitly requests off-thread application, even if a fast worker
|
||||
// finishes before this thread is scheduled again. Apply on the next frame.
|
||||
if !wait.is_zero() {
|
||||
match rx.recv_timeout(wait) {
|
||||
Ok(evaluated) => return Start::Now(evaluated),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => return Start::Now(None),
|
||||
Ok(evaluated) => return Start::Now(evaluated, Some(kept)),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => return Start::Now(None, Some(kept)),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {}
|
||||
}
|
||||
}
|
||||
Start::Later(Deferred { done: rx, evaluated: None, started: crate::now_ms(), command, revision: self.session.revision })
|
||||
Start::Later(Deferred { done: rx, evaluated: None, started: crate::now_ms(), command, revision: self.session.revision, kept: Some(kept) })
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn begin_deferred(&self, _id: &str, _params: &Value) -> Start {
|
||||
Start::Now(None)
|
||||
Start::Now(None, None)
|
||||
}
|
||||
}
|
||||
@@ -85,6 +85,41 @@ fn a_command_computed_off_the_thread_is_not_evaluated_again() {
|
||||
assert!((v - (12500.0 - hole)).abs() < 1.0, "{v}");
|
||||
}
|
||||
|
||||
/// A parameter change computed off the window thread runs here without computing a feature
|
||||
/// again, even with the evaluation cache emptied meanwhile (a design whose states pass its
|
||||
/// budget): it evaluates once before its sketch stores the new solution and once after, and the
|
||||
/// first of those is kept for the run here too, not only the last.
|
||||
#[test]
|
||||
fn a_parameter_change_computed_off_the_thread_is_not_evaluated_again() {
|
||||
let mut h = Harness::new();
|
||||
h.app.home.open = false;
|
||||
for (id, p) in [
|
||||
("parameters.add", json!({"name": "W", "expression": "40 mm"})),
|
||||
("sketch.create", json!({"plane": "XY", "name": "Base"})),
|
||||
("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [40, 20]})),
|
||||
("sketch.dimension", json!({"entities": ["l1"], "value": "W"})),
|
||||
("sketch.finish", json!({})),
|
||||
("solid.extrude", json!({"distance": 10})),
|
||||
("solid.box", json!({"corner": [5, 5, 10], "length": 10, "width": 10, "height": 5, "operation": "join"})),
|
||||
] {
|
||||
h.app.run(id, p).unwrap();
|
||||
}
|
||||
h.app.apply_off_thread = Some(Duration::ZERO);
|
||||
h.app.run_heavy("parameters.change", json!({"name": "W", "expression": "50 mm"})).unwrap();
|
||||
for _ in 0..500 {
|
||||
if h.app.deferred.as_mut().is_some_and(crate::deferred::Deferred::finished) {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
h.app.session.model.cache = Default::default();
|
||||
let before = h.app.session.model.recomputed;
|
||||
until_settled(&mut h);
|
||||
assert_eq!(h.app.session.model.recomputed - before, 0, "nothing computed again on the window thread, in either evaluation");
|
||||
let v = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((v - (50.0 * 20.0 * 10.0 + 500.0)).abs() < 1.0, "{v}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_marker_moved_again_replaces_the_move_still_waiting() {
|
||||
let mut h = block_boss_hole();
|
||||
|
||||
Reference in new issue
Block a user