SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch drag: a live frame stops once its numerical solves have done their share (#6330)
semmelrinde43f21e8fecf1
diff --git a/crates/engine/src/cmd/sketch_drag.rs b/crates/engine/src/cmd/sketch_drag.rsindex d2fab75719..c1c8c851d9 100644--- a/crates/engine/src/cmd/sketch_drag.rs+++ b/crates/engine/src/cmd/sketch_drag.rs@@ -190,6 +190,7 @@ pub(super) fn drag_entity(solves.count += 1;solves.work += budget.spent() - spent;solves.cut |= budget.exhausted();+ solves.numeric |= budget.numeric_exhausted();let outcome = if !ok {Step::Failed} else if last.sweep_wrapped(sk) {@@ -210,7 +211,15 @@ pub(super) fn drag_entity(let (mut base, mut dt, mut k, mut t) = (0.0, 1.0 / n as f64, 0, 0.0);let mut shortened = false;let mut wrapped = false;+ let mut out_of_frame = false;'walk: while t < 1.0 {+ // A live frame whose numerical solves have done their share takes no more steps: the+ // rest of the way waits for the next frame (`retry`), instead of seconds of held solves+ // in this one, all failing where the geometry can't follow.+ if solves.numeric {+ out_of_frame = true;+ break 'walk;+ }if solves.cut && !shortened {shortened = true;let rest = 1.0 - t;@@ -251,7 +260,7 @@ pub(super) fn drag_entity(let fine = dt / HALVINGS as f64;let mut miss = t;let mut first = true;- while spare > 0 && miss - good > fine {+ while spare > 0 && miss - good > fine && !solves.numeric {spare -= 1;let mid = if std::mem::take(&mut first) { good + fine } else { 0.5 * (good + miss) };match step(sk, &last, mid, &mut solves) {@@ -305,7 +314,8 @@ pub(super) fn drag_entity(let d = to - start;if at.dist(to) < 1e-6 || d.dot(d) == 0.0 { 1.0 } else { ((at - start).dot(d) / d.dot(d)).clamp(0.0, 1.0) }});- let retry = frame.as_ref().is_some_and(Budget::exhausted) && start.zip(at).is_some_and(|(a, b)| a.dist(b) > 1e-9);+ let spent = out_of_frame || frame.as_ref().is_some_and(Budget::exhausted);+ let retry = spent && start.zip(at).is_some_and(|(a, b)| a.dist(b) > 1e-9);return (Dragged { reached, moving, line_grab, retry }, Left::Solved);}}@@ -320,7 +330,8 @@ pub(super) fn drag_entity(None if good > 0.0 => Left::Solved,None => Left::Unsolved,};- (Dragged { reached: good, moving, line_grab, retry: false }, left)+ // The next frame goes on only from progress: a grab that can't move asks for no more.+ (Dragged { reached: good, moving, line_grab, retry: out_of_frame && good > 0.0 }, left)}/// The held solves of one drag: how many, their shared work (including cursor correction),@@ -330,6 +341,8 @@ pub(super) struct Solves {pub count: usize,pub work: usize,pub cut: bool,+ /// The frame's numerical solves have done their share ([`Budget::numeric_exhausted`]).+ pub numeric: bool,}/// One live frame's decomposition budget (smaller in tests that set one).@@ -338,6 +351,10 @@ fn frame_budget() -> Budget {if let Some(work) = last_drag::frame_work() {return Budget::new(work);}+ #[cfg(test)]+ if let Some(work) = last_drag::frame_numeric() {+ return Budget::frame().with_numeric(work);+ }Budget::frame()}@@ -349,8 +366,9 @@ pub(super) mod last_drag {use super::Solves;thread_local! {- static LAST: Cell<Solves> = const { Cell::new(Solves { count: 0, work: 0, cut: false }) };+ static LAST: Cell<Solves> = const { Cell::new(Solves { count: 0, work: 0, cut: false, numeric: false }) };static FRAME: Cell<Option<usize>> = const { Cell::new(None) };+ static NUMERIC: Cell<Option<usize>> = const { Cell::new(None) };}pub fn set(s: Solves) {@@ -380,6 +398,25 @@ pub(super) mod last_drag {let _restore = Restore(FRAME.with(|c| c.replace(Some(work))));f()}++ pub fn frame_numeric() -> Option<usize> {+ NUMERIC.with(Cell::get)+ }++ /// Restores the numerical allowance when dropped, also when the test panics.+ struct RestoreNumeric(Option<usize>);++ impl Drop for RestoreNumeric {+ fn drop(&mut self) {+ NUMERIC.with(|c| c.set(self.0));+ }+ }++ /// Run `f` with live frames given `work` units for their numerical solves.+ pub fn with_frame_numeric<R>(work: usize, f: impl FnOnce() -> R) -> R {+ let _restore = RestoreNumeric(NUMERIC.with(|c| c.replace(Some(work))));+ f()+ }}/// How one held solve of a drag went.diff --git a/crates/engine/src/cmd/sketch_ux_tests.rs b/crates/engine/src/cmd/sketch_ux_tests.rsindex 8b2ca858eb..24f3b41f46 100644--- a/crates/engine/src/cmd/sketch_ux_tests.rs+++ b/crates/engine/src/cmd/sketch_ux_tests.rs@@ -1447,6 +1447,27 @@ fn a_drag_out_of_decomposition_budget_takes_short_steps() {assert_eq!(flips, 0);}+/// A live frame whose numerical solves have done their share takes no more held solves. Before,+/// a large sketch's frame could run 64 failing held solves of 150 ms each (10 s), where the+/// geometry couldn't follow. Progress so far stays and asks for another frame (`retry`).+#[test]+fn a_live_frame_stops_once_its_numerical_solves_are_spent() {+ let start = hung_arm();+ let h = pt(&start, "eh.end");+ let far = hung_hand_target(&start, 2.0, 1.5);+ let drag = |s: &mut Session| run(s, "sketch.drag", json!({"entity": "eh.end", "from": [h.x, h.y], "to": [far.x, far.y], "live": true}));+ let mut s = hung_arm();+ drag(&mut s);+ let whole = super::drag::last_drag::get();+ let mut s = hung_arm();+ let r = super::drag::last_drag::with_frame_numeric(1, || drag(&mut s));+ let short = super::drag::last_drag::get();+ assert!(short.numeric && short.count < whole.count, "{short:?} against {whole:?}");+ // What it reached stays, and asks for the next frame.+ let reached = r["reached"].as_f64().unwrap_or(0.0);+ assert!(reached > 0.0 && reached < 1.0 && r["retry"] == json!(true), "{r}");+}+/// All the held solves of one live frame, halvings included, share one decomposition budget:/// together they do at most a frame's work, and one solve's more.#[test]diff --git a/crates/sketch/src/decompose.rs b/crates/sketch/src/decompose.rsindex 58afd2272e..0e85462a0a 100644--- a/crates/sketch/src/decompose.rs+++ b/crates/sketch/src/decompose.rs@@ -83,20 +83,44 @@ pub struct Budget {left: usize,spent: usize,cut: bool,+ /// A live drag frame's allowance for the numerical solves (LM), which are counted but never+ /// stopped by it: once it is spent, the drag takes no more steps this frame (`None`: not+ /// counted).+ numeric_left: Option<usize>,}impl Budget {/// A budget of `work` units: membership scans or estimated dense arithmetic operations.pub fn new(work: usize) -> Budget {- Budget { left: work, spent: 0, cut: false }+ Budget { left: work, spent: 0, cut: false, numeric_left: None }}/// The budget of one solve: about 0.3 s, so a hostile sketch can't stall it.pub fn full() -> Budget {Budget::new(MAX_WORK)}- /// The budget of one live drag frame: about 16 ms.+ /// The budget of one live drag frame: about 16 ms, and as much again for its numerical+ /// solves ([`Budget::numeric_exhausted`]).pub fn frame() -> Budget {- Budget::new(FRAME_WORK)+ Budget { numeric_left: Some(FRAME_WORK), ..Budget::new(FRAME_WORK) }+ }+ /// The frame's numerical solves have done their share of work: a drag takes no more steps+ /// this frame and goes on in the next.+ pub fn numeric_exhausted(&self) -> bool {+ self.numeric_left == Some(0)+ }+ /// This budget with `work` units for its numerical solves (a frame that runs out sooner).+ pub fn with_numeric(self, work: usize) -> Budget {+ Budget { numeric_left: Some(work), ..self }+ }+ /// Whether the numerical solves' work is counted ([`Budget::frame`]).+ pub(crate) fn counts_numeric(&self) -> bool {+ self.numeric_left.is_some()+ }+ /// Count a numerical solve's work against the frame's allowance.+ pub(crate) fn charge_numeric(&mut self, work: usize) {+ if let Some(left) = &mut self.numeric_left {+ *left = left.saturating_sub(work);+ }}/// Some decomposition or cursor work stopped because the budget ran out.pub fn exhausted(&self) -> bool {diff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rsindex 18e374e21c..3df93dfbb5 100644--- a/crates/sketch/src/solver.rs+++ b/crates/sketch/src/solver.rs@@ -978,6 +978,26 @@ fn lm(sk: &Sketch, lay: &Layout, blocks: &[(Block, Vec<usize>)], vars: &[usize],lm_capped(sk, lay, blocks, vars, x, col, MAX_ITERS)}+/// [`lm`], counting its work against a live drag frame's numerical allowance when `budget` has+/// one ([`Budget::frame`]). The solve itself runs as it would without it.+fn lm_in(+ sk: &Sketch,+ lay: &Layout,+ blocks: &[(Block, Vec<usize>)],+ vars: &[usize],+ x: &mut Vec<f64>,+ col: &[usize],+ budget: &mut Budget,+) -> (usize, f64) {+ if !budget.counts_numeric() {+ return lm(sk, lay, blocks, vars, x, col);+ }+ let mut meter = Budget::new(usize::MAX);+ let out = lm_capped_with_budget(sk, lay, blocks, vars, x, col, MAX_ITERS, Some(&mut meter)).unwrap_or((0, f64::INFINITY));+ budget.charge_numeric(meter.spent());+ out+}+/// [`lm`] with at most `max_iters` iterations.fn lm_capped(sk: &Sketch,@@ -2275,7 +2295,7 @@ fn solve_inner(let rest = unpinned(vars, &pin, None);let rest_blocks = blocks_reading(&sub, &rest);columns(&mut col, &rest, vars);- let (its, r) = if rest.is_empty() { (0, 0.0) } else { lm(sk, &lay, &rest_blocks, &rest, &mut x, &col) };+ let (its, r) = if rest.is_empty() { (0, 0.0) } else { lm_in(sk, &lay, &rest_blocks, &rest, &mut x, &col, budget) };iterations += its;residual = r;solved = residual < ACCEPT;@@ -2299,7 +2319,7 @@ fn solve_inner(// the seed did not move it.let reseeded = unseeded.as_ref().filter(|plain| vars.iter().any(|v| plain.get(*v).is_some_and(Option::is_some)));if !(solved || pinned_failed && reseeded.is_some()) {- let (its, r) = lm(sk, &lay, &sub, vars, &mut x, &col);+ let (its, r) = lm_in(sk, &lay, &sub, vars, &mut x, &col, budget);iterations += its;residual = r;}@@ -2313,7 +2333,7 @@ fn solve_inner(*s = plain.get(v).copied().flatten().unwrap_or(*s0);}}- let (its, r) = lm(sk, &lay, &sub, vars, &mut x, &col);+ let (its, r) = lm_in(sk, &lay, &sub, vars, &mut x, &col, budget);iterations += its;residual = r;}@@ -2344,7 +2364,7 @@ fn solve_inner(iterations += its;if !done {// The last sub-step's solution, solved for the new values in one jump.- let (its, r) = lm(sk, &lay, &sub, vars, &mut from, &col);+ let (its, r) = lm_in(sk, &lay, &sub, vars, &mut from, &col, budget);iterations += its;done = edit.holds(r, &State { sk, lay: &lay, x: &from });}