SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Desktop app: closing a design stops its kernel work, and designs build the same on any kernel (#11771)
bherbruckfabeaa329aef
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 802cd1c3d5..8b05a95760 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -349,16 +349,20 @@ impl Ahead {/// [`Ahead::evaluate`], setting `step` to the number of the command running (from 1), so a/// front end can say how far a batch has got.pub fn evaluate_counting(self, commands: &[(String, Value)], step: &std::sync::atomic::AtomicUsize) -> Result<Evaluated> {- let (after, _) = self.0.preview_in_place(commands, Some(step))?;- after.world_state()?.warm_display();- Ok(Evaluated(after.model))+ let stop = self.0.stop.clone();+ stop.within(|| {+ let (after, _) = self.0.preview_in_place(commands, Some(step))?;+ after.world_state()?.warm_display();+ Ok(Evaluated(after.model))+ })}/// 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()+ let stop = self.0.stop.clone();+ stop.within(|| commands.iter().map(|(id, params)| self.0.execute(id, params)).collect())}}@@ -534,6 +538,10 @@ pub struct Session {/// not a move of the design's, so the placements the design reports and Capture Position/// keeps leave it out ([`Session::uncaptured_moves`]).pub exploded: std::collections::BTreeMap<u64, solidcraft_doc::Mat>,+ /// Stops the work computing off the window thread for this design, shared with its copies.+ stop: solidcraft_kernel::Stop,+ /// A copy of a design ([`Session::scratch`]), sharing its token.+ is_copy: bool,world_cache: std::sync::Mutex<Option<WorldCache>>,/// The design the joints were last solved for, as the solve left it, and the model it read/// (see [`Session::solve_joints`]).@@ -794,6 +802,8 @@ impl Session {/// A session on `doc` evaluated as `model`, with what it hides.pub(crate) fn with_model(doc: Arc<Document>, visibility: Visibility, model: Model) -> Self {Session {+ stop: Default::default(),+ is_copy: false,saved: doc.clone(),doc,model,@@ -874,6 +884,11 @@ impl Session {/// design before the batch, which is what the batch promised (#3242). The design is what a/// checkpoint keeps, not the replaced session's file path (docs/mcp.md).pub fn replace_design(&mut self, fresh: Session) {+ // Nothing still computing for the design that leaves has anywhere to go. A copy leaves+ // the design it came from going, and its token with it.+ if !self.is_copy {+ self.stop_computing();+ }let auto_project = self.auto_project;let validation = self.validation();let single_surface_analysis = self.single_surface_analysis;@@ -905,6 +920,19 @@ impl Session {self.replacements = replacements;}+ /// The token over the work running off the window thread for this design, on any of its+ /// copies: a job started from a copy runs [`solidcraft_kernel::Stop::within`] it.+ pub fn stop_token(&self) -> solidcraft_kernel::Stop {+ self.stop.clone()+ }++ /// This design is going away: the work still computing for it stops at the kernel's next+ /// check, and its results go nowhere (they are only ever for this design's evaluation cache).+ /// A kernel call that doesn't check runs to its end, on a kernel of its own, holding up nothing.+ pub fn stop_computing(&self) {+ self.stop.stop();+ }+/// Install (or with `None` remove) the check [`Session::execute`] runs before every command,/// for an app that embeds the engine and decides which commands may run. A refusal comes back/// as [`EngineError::Refused`] and leaves the session as it was.@@ -1871,6 +1899,8 @@ impl Session {/// commands on without touching this one.pub fn scratch(&self) -> Session {Session {+ stop: self.stop.clone(),+ is_copy: true,doc: self.doc.clone(),model: self.model.clone(),undo: Vec::new(),@@ -1989,6 +2019,16 @@ impl Session {commands: &[(String, Value)],marker: Option<Option<usize>>,original: Option<Session>,+ ) -> Result<ComputedCommands> {+ let stop = self.stop.clone();+ stop.within(|| self.compute_commands_under(commands, marker, original))+ }++ fn compute_commands_under(+ self,+ commands: &[(String, Value)],+ marker: Option<Option<usize>>,+ original: Option<Session>,) -> Result<ComputedCommands> {let editor_original = original.as_ref().map(|session| session.doc.clone());let mut computed = self.scratch();diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 6449b1ac6c..bf5e31d3be 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -410,6 +410,7 @@ mod curved_seam_round;mod flush_join_loft;mod gltf_import;mod import_component;+mod kernel_pool;mod large_step_import;mod loft_ring;mod loft_spacing;diff --git a/crates/engine/src/tests/kernel_pool.rs b/crates/engine/src/tests/kernel_pool.rsnew file mode 100644index 0000000000..dad34b6529--- /dev/null+++ b/crates/engine/src/tests/kernel_pool.rs@@ -0,0 +1,181 @@+//! A design's bodies are made and used on whichever kernel of the pool is free+//! (`solidcraft_smlib`'s `core::Pool`). What it builds must not depend on which: to the last+//! number, on a new kernel or one that has done much, while another is busy, with bodies made on+//! one kernel going into operations on another, through the evaluation cache, undo and redo.++use super::*;++/// A hole, a round and a chamfer, each building on the last.+fn features() -> Vec<(&'static str, Value)> {+ vec![+ ("solid.box", json!({"length": 40, "width": 30, "height": 20})),+ ("solid.cylinder", json!({"base": [12, 15, -1], "axis": [0, 0, 1], "radius": 3.4, "height": 30, "operation": "cut"})),+ ("solid.fillet", json!({"edges": [[0, 0, 10]], "radius": 2})),+ ("solid.chamfer", json!({"edges": [[20, 0, 20]], "distance": 1})),+ ]+}++fn join() -> (&'static str, Value) {+ ("solid.box", json!({"corner": [25, 10, 20], "length": 10, "width": 10, "height": 5, "operation": "join"}))+}++/// Everything a design built, exactly: each body's name, whole B-rep record and triangle count.+fn built(s: &Session) -> Vec<String> {+ let st = s.model.state();+ st.bodies+ .iter()+ .map(|b| {+ let record = serde_json::to_string(b.body.record()).unwrap();+ format!("{} {} {record}", b.name, b.mesh().triangles.len())+ })+ .collect()+}++fn design(features: &[(&'static str, Value)]) -> Session {+ let mut s = Session::default();+ for (id, p) in features {+ run(&mut s, id, p.clone());+ }+ s+}++fn assert_same(what: &str, a: &[String], b: &[String]) {+ assert_eq!(a.len(), b.len(), "{what}: how many bodies");+ assert!(a == b, "{what}: the design built differently");+}++#[test]+fn a_design_rebuilds_the_same_on_any_kernel() {+ let f = features();+ let first = built(&design(&f));+ assert!(!first.is_empty());+ // On a new kernel, the one that built it above busy elsewhere.+ let held = solidcraft_kernel::hold_a_kernel();+ assert_same("a new kernel", &first, &built(&design(&f)));+ // And another new one, with both of those out of use.+ let held_too = solidcraft_kernel::hold_a_kernel();+ assert_same("another new kernel", &first, &built(&design(&f)));+ drop((held, held_too));+ // On one that has built plenty since.+ for _ in 0..3 {+ design(&f);+ }+ assert_same("a kernel that did much before", &first, &built(&design(&f)));+}++/// A curvature round, whose procedural blends take their serials from the kernel: one body made+/// on each of two kernels, the serials of neither mistaken for the other's in the kernel that+/// solves stations for both.+#[test]+fn a_procedural_blend_builds_the_same_on_any_kernel() {+ let f = vec![+ ("solid.box", json!({"length": 40, "width": 30, "height": 20})),+ ("solid.fillet", json!({"edges": [[20, 0, 20]], "radius": 3, "type": "curvature"})),+ ];+ let first = design(&f);+ let held = solidcraft_kernel::hold_a_kernel();+ let second = design(&f);+ let b = built(&second);+ assert_same("a new kernel", &built(&first), &b);+ let v = |s: &mut Session| run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();+ let (mut first, mut second) = (first, second);+ let beside = v(&mut second);+ drop(held);+ assert_eq!(v(&mut first).to_bits(), beside.to_bits(), "one measured right after the other on one kernel");+}++/// A modeled thread, a screw sweep and its boolean, on a short hole.+#[test]+fn a_thread_builds_the_same_on_any_kernel() {+ let f = vec![+ ("solid.box", json!({"length": 20, "width": 20, "height": 4})),+ ("solid.cylinder", json!({"base": [10, 10, -1], "axis": [0, 0, 1], "radius": 3.4, "height": 10, "operation": "cut"})),+ ("solid.thread", json!({"face": [13.4, 10, 2], "modeled": true})),+ ];+ let first = built(&design(&f));+ let held = solidcraft_kernel::hold_a_kernel();+ assert_same("a new kernel", &first, &built(&design(&f)));+ drop(held);+}++/// Bodies from the evaluation cache and the undo stack go on into operations on another kernel:+/// the join's boolean takes a body the held kernel made, undo restores it, redo brings back the+/// join's, and each is what the whole design built in one go on a single kernel gives.+#[test]+fn bodies_from_another_kernel_go_on_through_the_cache_undo_and_redo() {+ let f = features();+ let mut all = f.clone();+ all.push(join());+ let (before, after) = (built(&design(&f)), built(&design(&all)));++ let mut s = design(&f);+ let held = solidcraft_kernel::hold_a_kernel();+ let (id, p) = join();+ run(&mut s, id, p);+ assert_same("joined on another kernel", &after, &built(&s));+ run(&mut s, "edit.undo", json!({}));+ assert_same("undone", &before, &built(&s));+ drop(held);+ let held = solidcraft_kernel::hold_a_kernel();+ run(&mut s, "edit.redo", json!({}));+ assert_same("redone", &after, &built(&s));+ // Rebuilt without the cache, every feature again, while that kernel stays out of use.+ s.model.no_cache = true;+ *s.model.cache.lock().unwrap() = Default::default();+ run(&mut s, "timeline.roll_to", json!({"position": 0}));+ run(&mut s, "timeline.roll_to", json!({}));+ assert_same("rebuilt from the start", &after, &built(&s));+ drop(held);+ // And the body goes on from there, back on the first kernel.+ run(&mut s, "solid.box", json!({"corner": [-5, 0, 0], "length": 5, "width": 5, "height": 5, "operation": "join"}));+ let mut more = all.clone();+ more.push(("solid.box", json!({"corner": [-5, 0, 0], "length": 5, "width": 5, "height": 5, "operation": "join"})));+ assert_same("a further join", &built(&design(&more)), &built(&s));+}++/// A design rebuilt while other work keeps kernels of the pool busy on other threads builds what+/// it builds alone, whichever kernels its calls happen to get.+#[test]+fn a_design_rebuilt_beside_other_work_builds_the_same() {+ let f = features();+ let alone = built(&design(&f));+ let done = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));+ let busy: Vec<_> = (0..3)+ .map(|_| {+ let (done, f) = (done.clone(), f.clone());+ std::thread::spawn(move || {+ while !done.load(std::sync::atomic::Ordering::Relaxed) {+ design(&f);+ }+ })+ })+ .collect();+ for _ in 0..3 {+ assert_same("beside other work", &alone, &built(&design(&f)));+ }+ done.store(true, std::sync::atomic::Ordering::Relaxed);+ for b in busy {+ b.join().unwrap();+ }+}++/// A copy that replaces its own design leaves the design it was copied from going: the token over+/// that design's work is stopped only when that design itself closes or is replaced.+#[test]+fn a_copy_replacing_its_design_does_not_stop_the_design_it_came_from() {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10}));+ let token = s.stop_token();+ let new = [("file.new".to_string(), json!({}))];+ assert!(s.ahead().replies(&new).iter().all(Result::is_ok));+ assert!(!token.is_stopped(), "a copy evaluating ahead");+ let _ = s.scratch().compute_commands(&new, None);+ assert!(!token.is_stopped(), "a copy computing a dialog's commands");+ assert!(s.preview(&new).is_ok());+ assert!(!token.is_stopped(), "a preview");+ // It still works, and the design's own replacement does stop it.+ run(&mut s, "solid.box", json!({"corner": [20, 0, 0], "length": 10, "width": 10, "height": 10}));+ run(&mut s, "file.new", json!({}));+ assert!(token.is_stopped(), "the design itself replaced");+ assert!(!s.stop_token().is_stopped());+}diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex 4459d3dd08..7088179ecb 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -454,15 +454,18 @@ const MAX_REFUSAL_PROBES: usize = 20_000;impl Refusal {/// The refusal of `record` for `error`, with the face SMLib refuses on its own.- fn of(record: &Brep, error: &solidcraft_smlib::Error) -> Refusal {+ pub(crate) fn of(record: &Brep, error: &solidcraft_smlib::Error) -> Refusal {if let solidcraft_smlib::Error::Internal(why) = error {return Refusal { face: None, surface: None, why: why.clone(), internal: true };}let _span = solidcraft_profile::span("kernel", "smlib_refusal_face");- let alone = |f: usize| crate::surfaces::Parts::of(record, &[(f, false)]).and_then(|p| p.canonical()).map(|c| c.brep);- let face = (record.faces.len() <= MAX_REFUSAL_PROBES)- .then(|| (0..record.faces.len()).find(|&f| alone(f).is_ok_and(|r| solidcraft_smlib::Brep::from_record(&r, true).is_err())))- .flatten();+ // It is kept with the body for every later reader: a stopped job's probes must not decide it.+ let face = solidcraft_smlib::stop::unstoppable(|| {+ let alone = |f: usize| crate::surfaces::Parts::of(record, &[(f, false)]).and_then(|p| p.canonical()).map(|c| c.brep);+ (record.faces.len() <= MAX_REFUSAL_PROBES)+ .then(|| (0..record.faces.len()).find(|&f| alone(f).is_ok_and(|r| solidcraft_smlib::Brep::from_record(&r, true).is_err())))+ .flatten()+ });let surface = face.and_then(|f| record.faces.get(f)).map(|f| SurfaceKind::of(&f.surface));Refusal { face, surface, why: error.to_string(), internal: false }}@@ -545,7 +548,10 @@ impl Body {pub fn smlib(&self) -> Result<&solidcraft_smlib::Brep> {self.require_brep("an SMLib operation")?;self.smlib- .get_or_init(|| solidcraft_smlib::Brep::from_record(&self.record, true).map_err(|e| Refusal::of(&self.record, &e)))+ .get_or_init(|| {+ solidcraft_smlib::stop::unstoppable(|| solidcraft_smlib::Brep::from_record(&self.record, true))+ .map_err(|e| Refusal::of(&self.record, &e))+ }).as_ref().map_err(|r| if r.internal { KernelError::Internal(format!("SMLib: {}", r.why)) } else { KernelError::Failed(format!("SMLib: {}", r.why)) },diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 6ee0794b8d..847a63834b 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -215,6 +215,8 @@ pub use prism_curve::{PlanarPiece, PlanarSpline};pub use prism_measure::{PrismSection, certified_prism_equivalent, certified_prism_section};pub use repair::{Hole, RebuiltFace, RefusedFace, RepairOptions, RepairReport, SewnGap, repair};pub use sew::{EdgeSpec, FaceSpec, SurfSpec, sew, sew_touching};+pub use solidcraft_smlib::hold_a_kernel;+pub use solidcraft_smlib::stop::Stop;pub use solidcraft_smlib::trace as smlib_trace;pub use splitface::{SplitTool, split_body, split_faces, split_faces_with_map};pub use step::step_export;diff --git a/crates/kernel/src/par.rs b/crates/kernel/src/par.rsindex 972bac0d81..7633594c2d 100644--- a/crates/kernel/src/par.rs+++ b/crates/kernel/src/par.rs@@ -28,9 +28,10 @@ fn pool() -> Option<&'static rayon::ThreadPool> {/// thread. Waking the pool's workers costs tens of microseconds, so callers ask for it only/// when the items carry more work than that (decided from the work, not the item count).pub(crate) fn map<T: Sync, R: Send>(what: &'static str, items: &[T], parallel: bool, f: impl Fn(&T) -> Result<R> + Sync) -> Vec<Result<R>> {- // The workers run under the caller's validation mode (`crate::validation`).+ // The workers run under the caller's validation mode (`crate::validation`) and stop token.let scope = crate::validation::current();- let one = |item: &T| crate::validation::within(scope.clone(), || guard(what, || f(item)));+ let stop = solidcraft_smlib::stop::current();+ let one = |item: &T| solidcraft_smlib::stop::scoped(stop.clone(), || crate::validation::within(scope.clone(), || guard(what, || f(item))));// The browser build has no worker pool: everything runs on the calling thread.#[cfg(target_arch = "wasm32")]let _ = parallel;@@ -87,7 +88,8 @@ pub fn map_with_local_pools<T: Sync, R: Send>(items: &[T], max_threads: usize, f}let pool = cell.get().ok_or_else(|| crate::KernelError::Failed("missing mesh worker".into()))?;let scope = crate::validation::current();- pool.install(|| crate::validation::within(scope, || guard("mesh worker", || f(item))))+ let stop = solidcraft_smlib::stop::current();+ pool.install(|| solidcraft_smlib::stop::scoped(stop, || crate::validation::within(scope, || guard("mesh worker", || f(item)))))})};#[cfg(target_arch = "wasm32")]@@ -101,9 +103,12 @@ pub fn map_with_local_pools<T: Sync, R: Send>(items: &[T], max_threads: usize, f/// `f` over `items` as [`for_each_on_threads`] runs it, results in item order (`None` where an/// item panicked).pub fn map_on_threads<T: Sync, R: Send>(items: &[T], max_threads: usize, f: impl Fn(&T) -> R + Sync) -> Vec<Option<R>> {- // The threads run under the caller's validation mode (`crate::validation`).+ // The threads run under the caller's validation mode (`crate::validation`) and stop token.let scope = crate::validation::current();- let one = |item: &T| crate::validation::within(scope.clone(), || guard("parallel item", || Ok(f(item))).ok());+ let stop = solidcraft_smlib::stop::current();+ let one = |item: &T| {+ solidcraft_smlib::stop::scoped(stop.clone(), || crate::validation::within(scope.clone(), || guard("parallel item", || Ok(f(item))).ok()))+ };#[cfg(not(target_arch = "wasm32"))]{use std::sync::atomic::{AtomicUsize, Ordering};diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex cb0493222c..280e072ee2 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -2439,3 +2439,17 @@ fn a_box_cut_round_a_small_hole_of_a_long_plate_keeps_the_hole() {}}}++/// A refusal is kept with its body for every later reader: which face it names doesn't depend on+/// whether the job that found it had been stopped, whose probes would all be refused.+#[test]+fn a_stopped_job_does_not_decide_which_face_a_refusal_names() {+ let body = crate::build::box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();+ let why = solidcraft_smlib::Error::Argument;+ let plain = crate::body::Refusal::of(body.record(), &why);+ assert_eq!(plain.face, None, "every face of a box is taken on its own");+ let stop = crate::Stop::new();+ stop.stop();+ let stopped = stop.within(|| crate::body::Refusal::of(body.record(), &why));+ assert_eq!(stopped.face, plain.face);+}diff --git a/crates/smlib/src/core.rs b/crates/smlib/src/core.rsindex 1644b68a0d..f2a6475133 100644--- a/crates/smlib/src/core.rs+++ b/crates/smlib/src/core.rs@@ -11,7 +11,7 @@ use std::sync::{Mutex, PoisonError};use solidcore::geom::attribute::{AttributeStore, ObjectKey};use solidcore::geom::vector3d::Vec3;-use solidcore::kernel::{Kernel, KernelOptions, UpstreamFixes};+use solidcore::kernel::{CancelToken, Kernel, KernelOptions, Rng, UpstreamFixes};use solidcore::mass::integrator::properties::{PropertyAttributes, brep_volume};use solidcore::primitive::api_primitives as primitives;@@ -412,7 +412,8 @@ const HELD_BACK: &[&str] = &["fillet_refuse_rounds_breaking_through"];/// How far apart two kernels' procedural blend serials start. A body keeps the serials of the/// kernel that made it and may be used on any other, whose memo of solved stations is keyed by-/// serial alone: the ranges keep one definition's stations from answering for another's.+/// serial alone: the ranges keep one definition's stations from answering for another's. A serial+/// only names a definition, so which range one comes from changes no answer.pub(crate) const BLEND_SERIALS_PER_KERNEL: u64 = 1 << 40;/// A new kernel. Each takes the next range of blend serials, the first starting at 0.@@ -424,30 +425,85 @@ fn fresh() -> Kernel {k}-/// Most kernels kept for later calls; those over it are dropped when their call ends.-const MOST_IDLE: usize = 8;+/// The kernels calls run on. The lock is only held to take or put back a kernel, never during a+/// call: a call that runs long (or never returns) holds up nothing but its own body, so one+/// design's long operation never delays another's. Calls one after another all get the same+/// kernel; one that starts while another runs gets one of its own (solidcore keeps no global+/// state, and a body's identities are valid only in the kernel that issued them, so any kernel+/// takes any body).+///+/// A call stuck for good keeps its kernel and the thread it runs on, and costs nothing more: at+/// most `most_idle` kernels wait between calls, however many calls once ran side by side. A job+/// that starts again and sticks again holds one more each time, so at `most_running` calls a new+/// call fails, saying so, rather than grow without end or wait for calls that may never return.+pub(crate) struct Pool<K> {+ pub(crate) idle: Vec<K>,+ pub(crate) running: usize,+ pub(crate) most_idle: usize,+ pub(crate) most_running: usize,+}++impl<K> Pool<K> {+ /// A kernel for a call, the last used first; `None` when too many are running.+ pub(crate) fn take(&mut self, make: impl FnOnce() -> K) -> Option<K> {+ if self.running >= self.most_running {+ return None;+ }+ self.running += 1;+ Some(self.idle.pop().unwrap_or_else(make))+ }++ /// A call ended, handing back its kernel if it is fit to use again.+ pub(crate) fn put(&mut self, kernel: Option<K>) {+ self.running = self.running.saturating_sub(1);+ if let Some(kernel) = kernel+ && self.idle.len() < self.most_idle+ {+ self.idle.push(kernel);+ }+ }+}++/// Most calls at once. Far above what any work needs: an operation runs on at most 16 threads.+const MOST_RUNNING: usize = 256;++static POOL: Mutex<Pool<Kernel>> = Mutex::new(Pool { idle: Vec::new(), running: 0, most_idle: 8, most_running: MOST_RUNNING });++fn take_kernel() -> Option<Kernel> {+ POOL.lock().unwrap_or_else(PoisonError::into_inner).take(fresh)+}-/// The kernels no call is using, the last used on top. The lock is only held to take or put back-/// a kernel, never during a call: a call that runs long (or never returns) holds up nothing but-/// its own body, so one design's long operation never delays another's. Calls one after another-/// all get the same kernel, as a single kernel would serve them; one that starts while another-/// runs gets one of its own (solidcore keeps no global state, and a body's identities are valid-/// only in the kernel that issued them, so any kernel takes any body).-static IDLE: Mutex<Vec<Kernel>> = Mutex::new(Vec::new());+fn put_kernel(k: Option<Kernel>) {+ POOL.lock().unwrap_or_else(PoisonError::into_inner).put(k);+}-fn take_kernel() -> Kernel {- IDLE.lock().unwrap_or_else(PoisonError::into_inner).pop().unwrap_or_else(fresh)+/// What a call must not find from the calls before it: the same operation on the same bodies+/// answers the same on any kernel, however much that kernel did first. (Its draws of random rays,+/// the stations it remembers; marks, identities and what is only kept to reuse memory change no+/// answer. Tolerances and fixes are the same on every kernel.)+fn start_clean(k: &mut Kernel) {+ k.rng = Rng::new(KernelOptions::default().seed);+ *k.blend_station_memo.borrow_mut() = Default::default();+ k.fillet_point_step.set(None);+ k.upstream_ub_passed.clear();}-fn put_kernel(k: Kernel) {- let mut idle = IDLE.lock().unwrap_or_else(PoisonError::into_inner);- if idle.len() < MOST_IDLE {- idle.push(k);+/// A kernel kept out of use until dropped ([`crate::hold_a_kernel`]).+pub struct HeldKernel(Option<Kernel>);++impl Drop for HeldKernel {+ fn drop(&mut self) {+ put_kernel(self.0.take());}}+pub(crate) fn hold_a_kernel() -> HeldKernel {+ HeldKernel(take_kernel())+}+/// Runs `f` on a kernel of its own. A panic in solidcore is caught: the kernel, which it may have-/// left half-updated, is replaced by a fresh one and the call fails with [`Error::Internal`].+/// left half-updated, is dropped and the call fails with [`Error::Internal`]. A token over this+/// thread's work ([`crate::stop`]) stops it.pub(crate) fn run<T: dump::Answer>(call: &'static str, f: impl FnOnce(&mut Kernel) -> std::result::Result<T, solidcore::SolidError>) -> Result<T> {run_on(call, &[], f)}@@ -470,7 +526,26 @@ pub(crate) fn run_on<T: dump::Answer>(inputs: dump::Inputs<'_>,f: impl FnOnce(&mut Kernel) -> std::result::Result<T, solidcore::SolidError>,) -> Result<T> {- let mut k = take_kernel();+ let stop = crate::stop::token();+ if stop.as_ref().is_some_and(CancelToken::is_cancelled) {+ return Err(Error::Solidcore(format!("{call}: cancelled")));+ }+ call_on(call, inputs, stop, f)+}++/// [`run_on`], stopped by `stop`.+fn call_on<T: dump::Answer>(+ call: &'static str,+ inputs: dump::Inputs<'_>,+ stop: Option<CancelToken>,+ f: impl FnOnce(&mut Kernel) -> std::result::Result<T, solidcore::SolidError>,+) -> Result<T> {+ let Some(mut k) = take_kernel() else {+ log::warn!(target: "smlib", "{call}: refused, {MOST_RUNNING} kernel calls are still running");+ return Err(Error::Solidcore(format!("{call}: {MOST_RUNNING} kernel calls are still running")));+ };+ start_clean(&mut k);+ k.cancel = stop.clone();// A profiler span per call: where the kernel's time goes.let _span = solidcraft_profile::span("solidcore", call);let in_flight = dump::in_flight(call);@@ -495,6 +570,11 @@ pub(crate) fn run_on<T: dump::Answer>(}};drop(in_flight);+ // Stopped, it is no failure to look into, and solidcore may have left the kernel part way.+ if stop.is_some_and(|s| s.is_cancelled()) {+ put_kernel(None);+ return r;+ }let why = match &r {Ok(v) => v.refusal(),Err(e) => Some(e.to_string()),@@ -503,7 +583,8 @@ pub(crate) fn run_on<T: dump::Answer>(// The kernel the call ran on, or the fresh one that replaced it after a panic.dump::failed(&k, call, &why, inputs);}- put_kernel(k);+ k.cancel = None;+ put_kernel(Some(k));r}@@ -530,7 +611,8 @@ pub(crate) fn with_body<T: dump::Answer>(if body.0.is_poisoned() {return Err(Error::Internal(format!("{call}: the body was left unfinished by an earlier panic")));}- run_on(call, &[("brep", body)], |k| f(k, &mut body.0.lock().unwrap_or_else(PoisonError::into_inner)))+ // No token stops it: stopped part way, solidcore may leave the body it borrows half-changed.+ call_on(call, &[("brep", body)], None, |k| f(k, &mut body.0.lock().unwrap_or_else(PoisonError::into_inner)))}/// An axis-aligned box from its lower corner (`SmApiCreateBox`, as `smlib_make_box` checks it:diff --git a/crates/smlib/src/lib.rs b/crates/smlib/src/lib.rsindex 3a29a19a76..209ef8d8e9 100644--- a/crates/smlib/src/lib.rs+++ b/crates/smlib/src/lib.rs@@ -19,6 +19,7 @@ pub mod pcurves;mod sheets;mod split;pub mod ssi;+pub mod stop;pub mod sweeps;pub mod trace;pub mod trim;@@ -244,6 +245,13 @@ pub fn current_call() -> Option<String> {core::dump::current()}+/// Keeps one of the kernels calls run on out of use until dropped: the next calls run on another.+/// For tests of what happens when a design's bodies come from a kernel that is busy elsewhere.+#[doc(hidden)]+pub fn hold_a_kernel() -> core::HeldKernel {+ core::hold_a_kernel()+}+/// Is this thread inside a solidcore call? A panic there is caught and becomes/// [`Error::Internal`]; crash reports mark it recovered.pub fn in_call() -> bool {diff --git a/crates/smlib/src/ssi.rs b/crates/smlib/src/ssi.rsindex 99ee643976..d302982041 100644--- a/crates/smlib/src/ssi.rs+++ b/crates/smlib/src/ssi.rs@@ -129,7 +129,7 @@ impl Spec {impl Surface {/// solidcore's surface, made the first time it is needed.fn core(&self) -> Result<&crate::core::split::Tool> {- self.core.get_or_init(|| crate::core::ssi::surface(&self.spec)).as_ref().map_err(Clone::clone)+ self.core.get_or_init(|| crate::stop::unstoppable(|| crate::core::ssi::surface(&self.spec))).as_ref().map_err(Clone::clone)}pub(crate) fn spec(&self) -> &Spec {diff --git a/crates/smlib/src/stop.rs b/crates/smlib/src/stop.rsnew file mode 100644index 0000000000..0c19be1a4b--- /dev/null+++ b/crates/smlib/src/stop.rs@@ -0,0 +1,71 @@+//! Stopping the kernel calls of work nobody waits for any more: the jobs of a design that closed.+//! Work runs [`Stop::within`] its design's token; once the token is stopped, each operation under+//! it refuses to start, and one running stops when solidcore next checks ([`solidcore::kernel::Kernel::cancel`]).+//!+//! A stopped operation is an error like any other, and the caller's bodies are as they were: only+//! operations that build on copies stop. Calls that answer from a body itself ([`crate::core::with_body`],+//! measuring, say) always run to their end, since solidcore may leave what a stopped call borrows+//! half-changed.++use std::cell::RefCell;++use solidcore::kernel::CancelToken;++thread_local! {+ static CURRENT: RefCell<Option<Stop>> = const { RefCell::new(None) };+}++/// Stops the kernel work running under it, on every thread it reached.+#[derive(Clone, Debug, Default)]+pub struct Stop(CancelToken);++impl Stop {+ pub fn new() -> Stop {+ Stop::default()+ }++ /// Stop the work under this token, now and from now on.+ pub fn stop(&self) {+ self.0.cancel();+ }++ pub fn is_stopped(&self) -> bool {+ self.0.is_cancelled()+ }++ /// Run `f` with this token over the kernel work it does on this thread.+ pub fn within<R>(&self, f: impl FnOnce() -> R) -> R {+ scoped(Some(self.clone()), f)+ }+}++/// The token over this thread's work, to hand to the worker threads it starts.+pub fn current() -> Option<Stop> {+ CURRENT.with(|c| c.borrow().clone())+}++/// Run `f` under `stop` (`None`: under none), as [`current`] was on the thread that started it.+pub fn scoped<R>(stop: Option<Stop>, f: impl FnOnce() -> R) -> R {+ let previous = CURRENT.with(|c| c.replace(stop));+ struct Restore(Option<Option<Stop>>);+ impl Drop for Restore {+ fn drop(&mut self) {+ if let Some(previous) = self.0.take() {+ CURRENT.with(|c| *c.borrow_mut() = previous);+ }+ }+ }+ let _restore = Restore(Some(previous));+ f()+}++/// Run `f` so that no token stops it: for what fills a cell every later user of a body reads,+/// which must not keep a stopped job's error.+pub fn unstoppable<R>(f: impl FnOnce() -> R) -> R {+ scoped(None, f)+}++/// solidcore's token of the work on this thread.+pub(crate) fn token() -> Option<CancelToken> {+ CURRENT.with(|c| c.borrow().as_ref().map(|s| s.0.clone()))+}diff --git a/crates/smlib/src/tests.rs b/crates/smlib/src/tests.rsindex aaafbcdd36..1c04e47518 100644--- a/crates/smlib/src/tests.rs+++ b/crates/smlib/src/tests.rs@@ -78,7 +78,7 @@ fn calls_from_many_threads_are_serialised() {static DUMP_DIR_TESTS: std::sync::Mutex<()> = std::sync::Mutex::new(());/// Entry points that ask no kernel, so have nothing to say here.-const NO_KERNEL: [&str; 13] = [+const NO_KERNEL: [&str; 14] = ["inertia_tensor","is_valid","failed_tests",@@ -92,6 +92,7 @@ const NO_KERNEL: [&str; 13] = ["word","words","in_call",+ "hold_a_kernel",];const ANSWERING: [&str; 63] = [@@ -510,3 +511,82 @@ fn a_panic_beside_a_running_call_costs_only_its_own_kernel() {release.send(()).unwrap();held.join().unwrap().unwrap();}++/// A stuck call keeps its kernel and nothing more: the pool never holds more than its limit of+/// idle kernels however many calls ran side by side, and once as many calls as it allows are+/// stuck, a new call is refused rather than growing it or waiting.+#[test]+fn the_kernel_pool_stays_bounded_when_calls_stick() {+ let mut pool = core::Pool { idle: Vec::new(), running: 0, most_idle: 1, most_running: 3 };+ let mut made = 0;+ let mut make = || {+ made += 1;+ made+ };+ let (a, b, c) = (pool.take(&mut make), pool.take(&mut make), pool.take(&mut make));+ assert_eq!((a, b, c), (Some(1), Some(2), Some(3)), "side by side, each on its own");+ assert_eq!(pool.take(&mut make), None, "refused, not waiting, not one more");+ pool.put(a);+ assert_eq!(pool.take(&mut make), Some(1), "room again, its kernel used again");+ // The other two never come back here: they still count, and hold no idle slot.+ pool.put(Some(1));+ pool.put(b);+ assert_eq!(pool.idle, [1], "no more idle than allowed");+ assert_eq!(pool.running, 1, "one still stuck");+ // A stopped call's kernel is not used again.+ pool.put(None);+ assert_eq!(pool.running, 0);+ assert_eq!(pool.idle, [1]);+}++/// A stop reaches a running call at solidcore's next check and later calls before they start;+/// the kernel it ran on is not used again; calls of other work and answers from a body go on.+#[test]+fn a_stopped_call_ends_at_its_next_check_and_holds_up_nothing() {+ let stop = stop::Stop::new();+ let (started, is_started) = std::sync::mpsc::channel();+ let running = {+ let stop = stop.clone();+ std::thread::spawn(move || {+ stop.within(|| {+ let first: Result<()> = core::run("stopped_call", |k| {+ let _ = started.send(());+ // A long solidcore loop, until it is stopped.+ loop {+ k.check_cancelled("stopped_call")?;+ std::thread::yield_now();+ }+ });+ let next = Brep::make_box([0.0; 3], [1.0; 3]);+ (first, next.map(|_| ()))+ })+ })+ };+ is_started.recv().unwrap();+ let body = answered(|| Brep::make_box([0.0; 3], [10.0; 3]).unwrap());+ stop.stop();+ let (first, next) = answered(move || running.join().unwrap());+ assert!(first.is_err_and(|e| e.to_string().contains("cancel")));+ assert!(next.is_err_and(|e| e.to_string().contains("cancelled")), "refused before it starts");+ // Under a stopped token, a body still answers, and is as it was.+ let v = stop.within(|| body.volume(1e-7)).unwrap();+ assert!((v - 1000.0).abs() < 1e-6, "{v}");+ assert!(stop.within(|| body.boolean(&body, BooleanOp::Union)).is_err(), "an operation is refused");+ // What fills a shared cell is not stopped.+ assert!(stop.within(|| stop::unstoppable(|| Brep::make_box([0.0; 3], [1.0; 3]))).is_ok());+ // And nothing else is affected.+ let v = body.boolean(&body, BooleanOp::Union).unwrap().unwrap().volume(1e-7).unwrap();+ assert!((v - 1000.0).abs() < 1e-6, "{v}");+}++/// Every call starts with the same draws of random rays, whatever its kernel did before: what+/// depends on them answers the same on any kernel of the pool.+#[test]+fn every_call_starts_clean_on_any_kernel() {+ let draw = |k: &mut solidcore::kernel::Kernel| Ok(k.rng.next_f64());+ let first = core::run("draw", draw).unwrap();+ assert_eq!(core::run("draw", draw).unwrap(), first, "the same kernel, later");+ let held = hold_a_kernel();+ assert_eq!(core::run("draw", draw).unwrap(), first, "another kernel");+ drop(held);+}diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rsindex 78d15c8764..aa6877c195 100644--- a/crates/ui-egui/src/documents.rs+++ b/crates/ui-egui/src/documents.rs@@ -583,10 +583,11 @@ pub fn close(app: &mut SolveApp, i: usize, force: bool) {let next = if i + 1 < n { i + 1 } else { i - 1 };switch(app, next);}- if let Some(slot) = app.docs.slots.remove(i)- && let Some(a) = slot.autosave- {- a.discard();+ if let Some(slot) = app.docs.slots.remove(i) {+ slot.session.stop_computing();+ if let Some(a) = slot.autosave {+ a.discard();+ }}if app.docs.active > i {app.docs.active -= 1;diff --git a/crates/ui-egui/src/history_off_thread_tests.rs b/crates/ui-egui/src/history_off_thread_tests.rsindex 575911d30c..0994c1b197 100644--- a/crates/ui-egui/src/history_off_thread_tests.rs+++ b/crates/ui-egui/src/history_off_thread_tests.rs@@ -725,6 +725,33 @@ fn a_design_closed_while_its_history_computes_holds_up_nothing() {assert_eq!(h.app.dialog.as_ref().and_then(|d| d.command()), Some("solid.extrude"));}+/// Closing a design or replacing it stops the kernel work still computing for it; showing another+/// tab doesn't, since that design is still there to come back to.+#[test]+fn closing_a_design_stops_what_it_has_computing_and_a_tab_switch_does_not() {+ let mut h = block_boss_hole();+ let first = h.app.session.stop_token();+ let copy = h.app.session.ahead();+ crate::documents::new_tab(&mut h.app);+ assert!(!first.is_stopped(), "only another tab shown");+ let second = h.app.session.stop_token();+ assert!(!second.is_stopped());+ crate::documents::close(&mut h.app, 0, true);+ assert!(first.is_stopped(), "the first design closed");+ assert!(!second.is_stopped(), "this design goes on");+ assert!(+ copy.replies(&[("solid.box".to_string(), json!({"length": 1, "width": 1, "height": 1}))]).iter().all(Result::is_err),+ "its job gets nowhere"+ );+ h.app.run("solid.box", json!({"length": 10, "width": 10, "height": 10})).unwrap();+ h.app.run("file.new", json!({})).unwrap();+ assert!(second.is_stopped(), "replaced in its tab");+ assert!(!h.app.session.stop_token().is_stopped());+ h.app.run("solid.box", json!({"length": 10, "width": 10, "height": 10})).unwrap();+ crate::documents::close(&mut h.app, 0, true);+ assert!(!h.app.session.stop_token().is_stopped(), "the blank design that took the last tab's place");+}+/// A design's history command stays with its tab: another tab doesn't wait for it and doesn't get/// its result, even once it is in. Shown again, the design picks it up.#[test]diff --git a/crates/ui-egui/src/preview.rs b/crates/ui-egui/src/preview.rsindex cc5889fd57..3ad018e979 100644--- a/crates/ui-egui/src/preview.rs+++ b/crates/ui-egui/src/preview.rs@@ -438,8 +438,10 @@ fn spawn(pv: &mut PreviewState, key: u64, scratch: Session, cmds: Vec<(String, V// Watched by `progress`, so a job left behind for other inputs skips its remaining features.let watched = progress.clone();let spawned = std::thread::Builder::new().name("preview".into()).spawn(move || {- let job = solidcraft_engine::doc::progress::watch(watched, || {- if tool { compute_tool(&scratch, &cmds, colors) } else { compute(&scratch, &cmds, colors) }+ let job = scratch.stop_token().within(|| {+ solidcraft_engine::doc::progress::watch(watched, || {+ if tool { compute_tool(&scratch, &cmds, colors) } else { compute(&scratch, &cmds, colors) }+ })});let _ = tx.send(job);});