smlib: SOLIDCRAFT_KERNEL_ROUTES moves single families; the rig scores one at a time

SOLIDCRAFT_KERNEL_ROUTES=<op>=<smlib|solidcore>[,...] applies on top of SOLIDCRAFT_KERNEL or the
preference, read once; bad, empty, overlong or surplus items are logged and ignored, and `file`
stays on SMLib. diagnostics.kernel reports it as `overrides`.

`cargo xtask kernel-cases --kernel both --route <op>=solidcore[,...]` runs the solidcore side as
SMLib with those families on solidcore, labelled solidcore[ops], into <out>/solidcore-<ops>/.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SdcgExNEwfR9CX2RAzp2Pt
This commit is contained in:
Brett LawsonandClaude Opus 5.5 committed 2026-10-29 03:45:27 +01:00
1 parent c9b2c18eb7
commit 8dfdcefadb
6 files changed
+360 -33

No files matched your search

+6 -6
View File
@@ -41,7 +41,8 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("diagnostics.kernel", "Geometry Kernel", kernel).icon("bug_report").noundo().params(
"choice?: routed | smlib | solidcore (sets which kernel answers: routed = each operation on the kernel the routing \
table gives it, smlib = the C++ SMLib kernel for all, solidcore = its Rust port for all; bodies already computed \
keep their results). SOLIDCRAFT_KERNEL, when set, wins over it. Returns {choice, environment, routes: [{op, \
keep their results). SOLIDCRAFT_KERNEL, when set, wins over it, and SOLIDCRAFT_KERNEL_ROUTES (op=backend,...) \
moves single operations on top of both. Returns {choice, environment, overrides: {op: backend}, routes: [{op, \
route, backend}]}: route is the table's kernel for the operation, backend the one it runs on now",
),
CommandSpec::new("diagnostics.crash_test", "Crash Test", crash_test).icon("bug_report").noundo().enabled(crash_test_enabled).params(
@@ -58,11 +59,10 @@ fn kernel(_: &mut Session, p: &Value) -> Result<Value> {
let c = v.as_str().and_then(route::Choice::from_id).ok_or_else(|| bad("diagnostics.kernel", "`choice` is routed, smlib or solidcore"))?;
route::set_choice(c);
}
let routes: Vec<Value> = route::Op::ALL
.iter()
.map(|op| json!({ "op": format!("{op:?}").to_lowercase(), "route": op.route().id(), "backend": op.backend().id() }))
.collect();
Ok(json!({ "choice": route::choice().id(), "environment": route::overridden(), "routes": routes }))
let routes: Vec<Value> =
route::Op::ALL.iter().map(|op| json!({ "op": op.id(), "route": op.route().id(), "backend": op.backend().id() })).collect();
let overrides: serde_json::Map<String, Value> = route::overrides().iter().map(|(op, b)| (op.id().to_string(), json!(b.id()))).collect();
Ok(json!({ "choice": route::choice().id(), "environment": route::overridden(), "overrides": overrides, "routes": routes }))
}
fn dir(cmd: &str) -> Result<std::path::PathBuf> {
@@ -100,6 +100,9 @@ fn diagnostics_kernel_reports_and_sets_the_choice() {
}
let environment = route::overridden();
assert_eq!(r["environment"], json!(environment), "{r}");
// SOLIDCRAFT_KERNEL_ROUTES, as the families it moves.
let moved: serde_json::Map<String, serde_json::Value> = route::overrides().iter().map(|(op, b)| (op.id().to_string(), json!(b.id()))).collect();
assert_eq!(r["overrides"], serde_json::Value::Object(moved), "{r}");
for choice in ["solidcore", "smlib", "routed"] {
let c = route::Choice::from_id(choice).unwrap();
// `.smb` files stay on SMLib whatever is chosen.
@@ -109,7 +112,7 @@ fn diagnostics_kernel_reports_and_sets_the_choice() {
"routed" => op.route().id(),
other => other,
};
assert_eq!(op.backend_under(c).id(), want, "{choice}: {op:?}");
assert_eq!(op.backend_with(c, &route::Overrides::NONE).id(), want, "{choice}: {op:?}");
}
if !route::Op::ALL.iter().all(|op| op.backend_under(c) == op.route()) {
continue; // it would move other tests' bodies to another kernel
+200 -7
View File
@@ -8,6 +8,10 @@
//! `SOLIDCRAFT_KERNEL=smlib|solidcore` sends every operation to one kernel for the whole process
//! (the rig, the test matrix); otherwise the preference ([`set_choice`]) does, and its default
//! follows the table.
//!
//! `SOLIDCRAFT_KERNEL_ROUTES=<op>=<backend>[,…]` (for example `boolean=solidcore,measure=solidcore`)
//! then moves single families on top of that choice, so the rig can score one family at a time
//! ([`Overrides`]). `.smb` files stay on SMLib whatever either says.
use std::sync::OnceLock;
use std::sync::atomic::{AtomicU8, Ordering};
@@ -88,6 +92,36 @@ impl Op {
Op::File,
];
/// The lower-case name `diagnostics.kernel` and `SOLIDCRAFT_KERNEL_ROUTES` spell it with.
pub fn id(self) -> &'static str {
match self {
Op::Convert => "convert",
Op::Primitive => "primitive",
Op::Transform => "transform",
Op::Measure => "measure",
Op::Check => "check",
Op::Boolean => "boolean",
Op::Blend => "blend",
Op::Offset => "offset",
Op::Split => "split",
Op::Sweep => "sweep",
Op::History => "history",
Op::Ssi => "ssi",
Op::Flat => "flat",
Op::File => "file",
}
}
/// Back from [`Op::id`]; anything else is `None`.
pub fn from_id(id: &str) -> Option<Op> {
Op::ALL.into_iter().find(|op| op.id() == id)
}
/// Where this family sits in [`Op::ALL`].
fn index(self) -> usize {
Op::ALL.iter().position(|op| *op == self).unwrap_or(0)
}
/// The routing table: the kernel each family runs on when nothing overrides it. Every family
/// stays on SMLib until the rig shows solidcore's parity for it.
pub fn route(self) -> Backend {
@@ -109,18 +143,28 @@ impl Op {
}
}
/// The kernel this family runs on now: `SOLIDCRAFT_KERNEL`, else the preference, else
/// [`Op::route`]. `.smb` files stay on SMLib whatever is chosen.
/// The kernel this family runs on now: `SOLIDCRAFT_KERNEL_ROUTES` for it, else
/// `SOLIDCRAFT_KERNEL`, else the preference, else [`Op::route`]. `.smb` files stay on SMLib
/// whatever is chosen.
pub fn backend(self) -> Backend {
self.backend_under(choice())
}
/// The kernel this family runs on under `c`, whatever is in force now: what [`Op::backend`]
/// answers once `c` is the choice. `.smb` files stay on SMLib whatever is chosen.
/// answers once `c` is the choice (`SOLIDCRAFT_KERNEL_ROUTES` still applies on top).
pub fn backend_under(self, c: Choice) -> Backend {
self.backend_with(c, overrides())
}
/// The kernel this family runs on under `c` with the overrides `o`, read from neither the
/// environment nor the preference. `.smb` files stay on SMLib whatever is chosen.
pub fn backend_with(self, c: Choice, o: &Overrides) -> Backend {
if self == Op::File {
return Backend::Smlib;
}
if let Some(b) = o.get(self) {
return b;
}
match c {
Choice::Routed => self.route(),
Choice::Only(b) => b,
@@ -166,6 +210,101 @@ fn environment() -> Option<Choice> {
})
}
/// Families moved to a kernel one by one, on top of the choice: `SOLIDCRAFT_KERNEL_ROUTES`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
pub struct Overrides([Option<Backend>; Op::ALL.len()]);
impl Overrides {
/// No family moved.
pub const NONE: Overrides = Overrides([None; Op::ALL.len()]);
/// Longest `SOLIDCRAFT_KERNEL_ROUTES` read; a longer one is ignored whole.
pub const MAX_LEN: usize = 4096;
/// Items read; the rest are ignored.
pub const MAX_ITEMS: usize = 64;
/// Longest item read; a longer one is ignored.
const MAX_ITEM_LEN: usize = 64;
/// The kernel `op` is moved to, if any.
pub fn get(&self, op: Op) -> Option<Backend> {
self.0.get(op.index()).copied().flatten()
}
/// Whether no family is moved.
pub fn is_empty(&self) -> bool {
self.0.iter().all(Option::is_none)
}
/// Every moved family and its kernel, in table order.
pub fn iter(&self) -> impl Iterator<Item = (Op, Backend)> + '_ {
Op::ALL.into_iter().filter_map(|op| self.get(op).map(|b| (op, b)))
}
/// A `SOLIDCRAFT_KERNEL_ROUTES` value: comma-separated `<op>=<smlib|solidcore>`, spaces
/// around each part allowed, a later item for the same family winning. Returns the overrides
/// and a warning for each item ignored: an unknown family or kernel, an empty or overlong
/// item, `file` (always SMLib), items past [`Overrides::MAX_ITEMS`], or a whole value longer
/// than [`Overrides::MAX_LEN`].
pub fn parse(text: &str) -> (Overrides, Vec<String>) {
let mut o = Overrides::NONE;
let mut warnings = Vec::new();
if text.len() > Self::MAX_LEN {
warnings.push(format!("{} bytes, longer than {}; ignored", text.len(), Self::MAX_LEN));
return (o, warnings);
}
let mut items = text.split(',');
for item in items.by_ref().take(Self::MAX_ITEMS) {
let item = item.trim();
let shown: String = item.chars().take(Self::MAX_ITEM_LEN).collect();
if item.is_empty() {
warnings.push("an empty item; ignored".into());
continue;
}
if item.len() > Self::MAX_ITEM_LEN {
warnings.push(format!("`{shown}…`: longer than {} bytes; ignored", Self::MAX_ITEM_LEN));
continue;
}
let Some((op, backend)) = item.split_once('=') else {
warnings.push(format!("`{shown}`: not <op>=<smlib|solidcore>; ignored"));
continue;
};
let Some(op) = Op::from_id(op.trim()) else {
warnings.push(format!("`{shown}`: no operation family `{}`; ignored", op.trim()));
continue;
};
let Some(backend) = Backend::from_id(backend.trim()) else {
warnings.push(format!("`{shown}`: `{}` is not smlib or solidcore; ignored", backend.trim()));
continue;
};
if op == Op::File {
warnings.push(format!("`{shown}`: .smb files stay on smlib; ignored"));
continue;
}
if let Some(slot) = o.0.get_mut(op.index()) {
*slot = Some(backend);
}
}
if items.next().is_some() {
warnings.push(format!("more than {} items; the rest ignored", Self::MAX_ITEMS));
}
(o, warnings)
}
}
/// `SOLIDCRAFT_KERNEL_ROUTES`, read once; each item it ignores says so in the log.
pub fn overrides() -> &'static Overrides {
static ENV: OnceLock<Overrides> = OnceLock::new();
ENV.get_or_init(|| {
let Some(v) = std::env::var_os("SOLIDCRAFT_KERNEL_ROUTES") else { return Overrides::NONE };
let v = v.to_string_lossy();
let (o, warnings) = Overrides::parse(&v);
for w in warnings {
log::warn!(target: "smlib", "SOLIDCRAFT_KERNEL_ROUTES: {w}");
}
o
})
}
static PREFERENCE: AtomicU8 = AtomicU8::new(0);
/// The choice in force: `SOLIDCRAFT_KERNEL` when it is set, else the preference.
@@ -216,9 +355,63 @@ mod tests {
fn each_choice_routes_every_family_without_touching_the_preference() {
for op in Op::ALL {
let want = |b: Backend| if op == Op::File { Backend::Smlib } else { b };
assert_eq!(op.backend_under(Choice::Routed), op.route(), "{op:?}");
assert_eq!(op.backend_under(Choice::Only(Backend::Smlib)), want(Backend::Smlib), "{op:?}");
assert_eq!(op.backend_under(Choice::Only(Backend::Solidcore)), want(Backend::Solidcore), "{op:?}");
let none = &Overrides::NONE;
assert_eq!(op.backend_with(Choice::Routed, none), op.route(), "{op:?}");
assert_eq!(op.backend_with(Choice::Only(Backend::Smlib), none), want(Backend::Smlib), "{op:?}");
assert_eq!(op.backend_with(Choice::Only(Backend::Solidcore), none), want(Backend::Solidcore), "{op:?}");
assert_eq!(op.backend_under(Choice::Routed), op.backend_with(Choice::Routed, overrides()), "{op:?}");
}
}
#[test]
fn op_ids_are_the_lower_case_names_and_round_trip() {
for op in Op::ALL {
assert_eq!(op.id(), format!("{op:?}").to_lowercase());
assert_eq!(Op::from_id(op.id()), Some(op));
}
assert_eq!(Op::from_id("Boolean"), None);
assert_eq!(Op::from_id(""), None);
}
/// Overrides move only the families they name, on top of any choice; read from a string, not
/// the process's environment.
#[test]
fn overrides_move_single_families_on_top_of_the_choice() {
let (o, warnings) = Overrides::parse("boolean=solidcore, measure = solidcore");
assert!(warnings.is_empty(), "{warnings:?}");
assert_eq!(o.iter().collect::<Vec<_>>(), [(Op::Measure, Backend::Solidcore), (Op::Boolean, Backend::Solidcore)]);
for op in Op::ALL {
let moved = matches!(op, Op::Boolean | Op::Measure);
let want = if moved { Backend::Solidcore } else { op.route() };
assert_eq!(op.backend_with(Choice::Routed, &o), want, "{op:?}");
let want = if moved { Backend::Solidcore } else { Backend::Smlib };
assert_eq!(op.backend_with(Choice::Only(Backend::Smlib), &o), want, "{op:?}");
}
// Back to SMLib under an all-solidcore choice; the later item wins.
let (o, _) = Overrides::parse("check=solidcore,check=smlib");
assert_eq!(Op::Check.backend_with(Choice::Only(Backend::Solidcore), &o), Backend::Smlib);
assert_eq!(Op::Sweep.backend_with(Choice::Only(Backend::Solidcore), &o), Backend::Solidcore);
assert!(Overrides::parse("").0.is_empty());
}
/// Hostile values: every bad item is ignored with a warning, the good ones still apply, and
/// nothing panics or reads past the caps.
#[test]
fn overrides_ignore_bad_items_with_a_warning() {
let (o, w) = Overrides::parse("file=solidcore,truck=solidcore,boolean=truck,,=,boolean,BOOLEAN=solidcore,blend=solidcore=x,sweep=solidcore");
assert_eq!(o.iter().collect::<Vec<_>>(), [(Op::Sweep, Backend::Solidcore)]);
assert_eq!(w.len(), 8, "{w:?}");
assert_eq!(Op::File.backend_with(Choice::Routed, &o), Backend::Smlib);
let (o, w) = Overrides::parse(&"x".repeat(Overrides::MAX_LEN + 1));
assert!(o.is_empty() && w.len() == 1, "{w:?}");
let (o, w) = Overrides::parse(&format!("{}=solidcore,blend=solidcore", "a".repeat(200)));
assert_eq!((o.get(Op::Blend), w.len()), (Some(Backend::Solidcore), 1), "{w:?}");
let many = vec!["measure=solidcore"; Overrides::MAX_ITEMS].join(",") + ",blend=solidcore";
let (o, w) = Overrides::parse(&many);
assert_eq!((o.get(Op::Measure), o.get(Op::Blend), w.len()), (Some(Backend::Solidcore), None, 1), "{w:?}");
for hostile in [",,,,", "\0=\0", "boolean=solidcore\0", "é=ü,ü", "=solidcore", "boolean="] {
let (o, w) = Overrides::parse(hostile);
assert!(o.is_empty() && !w.is_empty(), "{hostile:?}: {w:?}");
}
}
@@ -226,7 +419,7 @@ mod tests {
/// table does is set here, so no other test's body changes kernel.
#[test]
fn the_preference_routes_unless_the_environment_overrides() {
if overridden() {
if overridden() || !overrides().is_empty() {
return;
}
let harmless = [Choice::Only(Backend::Smlib), Choice::Only(Backend::Solidcore)]
+12
View File
@@ -23,6 +23,18 @@ backend, keeps `docs/kernel-cases.md` as the SMLib report and writes the two sid
[`docs/kernel-cases-backends.md`](../../docs/kernel-cases-backends.md) (cases that differ first)
and `<out>/backends.json`.
`--route <op>=solidcore[,…]` (with `--kernel both` or `solidcore`) scores single operation
families: the solidcore side runs on SMLib (`SOLIDCRAFT_KERNEL=smlib`) with only the families
named moved to solidcore (`SOLIDCRAFT_KERNEL_ROUTES`), so an unported family (the body check, say)
doesn't hide the others' score. The smlib side stays plain SMLib. The report labels the side
`solidcore[boolean,measure]`, and its `results.json`, `dumps/`, `report.md`, `backends.json` and
`backends.md` go to `<out>/solidcore-boolean-measure/`, so runs don't overwrite each other. The
families are the lower-case names `diagnostics.kernel` prints (`file` stays on SMLib):
```sh
cargo xtask kernel-cases --kernel both --route boolean=solidcore --cli target/release/solidcraft-cli
```
## Rules
- **The answer never comes from a kernel.** Not from truck's output, nor any commercial
+133 -18
View File
@@ -12,6 +12,11 @@
//! (`SOLIDCRAFT_KERNEL`). A solidcore run keeps its results, dumps and report in `<out>/solidcore/`;
//! `both` runs every case on each, keeps `docs/kernel-cases.md` as the SMLib report and writes the
//! side by side to `docs/kernel-cases-backends.md` and `<out>/backends.json`.
//!
//! `--route <op>=solidcore[,…]` scores single operation families instead: the "solidcore" side runs
//! on SMLib (`SOLIDCRAFT_KERNEL=smlib`) with only those families moved to solidcore
//! (`SOLIDCRAFT_KERNEL_ROUTES`), its label names them (`solidcore[boolean,measure]`), and its
//! results, report and `backends.json` / `backends.md` go to `<out>/solidcore-<op>[-<op>…]/`.
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
@@ -40,13 +45,62 @@ pub(crate) struct Options {
out: PathBuf,
/// The backends each case runs on (`--kernel`, default SMLib alone).
pub(crate) kernels: Vec<&'static str>,
/// `--route`: the operation families the solidcore side moves to solidcore, on SMLib for the
/// rest; empty, solidcore answers every family.
routes: Vec<String>,
}
impl Options {
/// A backend's output folder: the run's own for SMLib, `<out>/<backend>/` for any other.
/// A backend's output folder: the run's own for SMLib, `<out>/<backend>/` for any other, and
/// `<out>/solidcore-<op>[-<op>…]/` for routed families.
fn out_of(&self, kernel: &str) -> PathBuf {
if kernel == "smlib" { self.out.clone() } else { self.out.join(kernel) }
match kernel {
"smlib" => self.out.clone(),
"solidcore" if !self.routes.is_empty() => self.out.join(format!("solidcore-{}", self.routes.join("-"))),
other => self.out.join(other),
}
}
/// What a backend's side is called in the reports: `solidcore[boolean,measure]` for routed
/// families.
fn label(&self, kernel: &str) -> String {
if kernel == "solidcore" && !self.routes.is_empty() { format!("solidcore[{}]", self.routes.join(",")) } else { kernel.to_string() }
}
/// The environment a backend's case processes get: `SOLIDCRAFT_KERNEL`, and for routed
/// families SMLib plus `SOLIDCRAFT_KERNEL_ROUTES`.
fn env(&self, kernel: &str) -> Vec<(&'static str, String)> {
if kernel == "solidcore" && !self.routes.is_empty() {
let routes = self.routes.iter().map(|op| format!("{op}=solidcore")).collect::<Vec<_>>().join(",");
vec![("SOLIDCRAFT_KERNEL", "smlib".into()), ("SOLIDCRAFT_KERNEL_ROUTES", routes)]
} else {
vec![("SOLIDCRAFT_KERNEL", kernel.into())]
}
}
}
/// The operation families `--route` may name: `Op::ALL` in crates/smlib/src/route.rs, as
/// `Op::id` spells them (a test keeps the two together). `file` is not one: `.smb` files stay on
/// SMLib.
const ROUTE_OPS: [&str; 13] =
["convert", "primitive", "transform", "measure", "check", "boolean", "blend", "offset", "split", "sweep", "history", "ssi", "flat"];
/// `--route boolean=solidcore,measure=solidcore`: the families, in table order, each once.
fn parse_routes(text: &str) -> Result<Vec<String>, String> {
let mut ops = Vec::new();
for item in text.split(',').map(str::trim) {
let Some((op, backend)) = item.split_once('=') else {
return Err(format!("--route: `{item}` is not <op>=solidcore"));
};
if backend.trim() != "solidcore" {
return Err(format!("--route: `{item}`: only solidcore routes (the other side is SMLib already)"));
}
if !ROUTE_OPS.contains(&op.trim()) {
return Err(format!("--route: no operation family `{}` ({})", op.trim(), ROUTE_OPS.join(", ")));
}
ops.push(op.trim().to_string());
}
Ok(ROUTE_OPS.iter().filter(|op| ops.iter().any(|o| o == *op)).map(|op| op.to_string()).collect())
}
/// The run's options; `out` is its output folder unless `--out` gives one.
@@ -61,7 +115,13 @@ pub(crate) fn options(rest: &[&str], out: &str) -> Result<Options, String> {
Some("both") => BACKENDS.to_vec(),
Some(k) => return Err(format!("--kernel: unknown backend '{k}' (smlib, solidcore or both)")),
};
Ok(Options { cli: arg("--cli"), area: arg("--area"), timeout: Duration::from_secs(secs), jobs, out, kernels })
let routes = match arg("--route") {
None if rest.contains(&"--route") => return Err("--route: give <op>=solidcore[,…]".into()),
None => Vec::new(),
Some(r) if kernels.contains(&"solidcore") => parse_routes(&r)?,
Some(_) => return Err("--route: needs --kernel solidcore or both".into()),
};
Ok(Options { cli: arg("--cli"), area: arg("--area"), timeout: Duration::from_secs(secs), jobs, out, kernels, routes })
}
/// Every case's full result as JSON, into the run's output folder.
@@ -121,7 +181,8 @@ fn run_case(o: &Options, case: &Path, kernel: &str) -> Value {
};
let mut dumps = std::ffi::OsString::from("--dumps=");
dumps.push(o.out_of(kernel).join("dumps"));
cmd.env("SOLIDCRAFT_KERNEL", kernel)
cmd.env_remove("SOLIDCRAFT_KERNEL_ROUTES")
.envs(o.env(kernel))
.current_dir(root())
.args(["kernel-cases", "--json"])
.arg(dumps)
@@ -195,7 +256,7 @@ fn run_on(o: &Options, list: &[PathBuf], kernels: &[&str]) -> Vec<Vec<Value>> {
// Case by case, each on every backend in turn.
let (Some(case), Some(kernel)) = (list.get(i / kernels.len().max(1)), kernels.get(i % kernels.len().max(1))) else { return };
let r = run_one(o, case, kernel);
let tag = if kernels.len() > 1 { format!("{kernel:<10}") } else { String::new() };
let tag = if kernels.len() > 1 { format!("{:<10} ", o.label(kernel)) } else { String::new() };
println!(
"{:<11} {tag}{}",
r["status"].as_str().unwrap_or("?").to_uppercase(),
@@ -293,8 +354,9 @@ fn source_kinds(dir: &Path, cited: &BTreeMap<String, Vec<String>>) -> Result<Str
Ok(md)
}
/// The report of one backend's run into `to` (relative to the repository root, or absolute).
fn write_report(dir: &Path, list: &[PathBuf], results: &[Value], kernel: &str, to: &Path) -> Result<String, String> {
/// The report of one backend's run into `to` (relative to the repository root, or absolute);
/// `kernel` is the backend's label, `env` what its processes were given.
fn write_report(dir: &Path, list: &[PathBuf], results: &[Value], kernel: &str, env: &str, to: &Path) -> Result<String, String> {
let key = |r: &Value| (r["area"].as_str().unwrap_or("").to_string(), r["case"].as_str().unwrap_or("").to_string());
let by_case: BTreeMap<(String, String), &Value> = results.iter().map(|r| (key(r), r)).collect();
// Coverage: per area, cases and their statuses; per source, its cases.
@@ -328,7 +390,7 @@ fn write_report(dir: &Path, list: &[PathBuf], results: &[Value], kernel: &str, t
"# Kernel regression rig\n\nGenerated by `cargo xtask kernel-cases`. Every geometry case the old kernel (truck) got wrong, as an issue, a PR or a crash report recorded it, is a use case in [`tests/kernel-cases/`](../tests/kernel-cases/) with its own right answer: numbers from analysis or a hand calculation (**analytic**) where the geometry has them, and otherwise the invariants (**invariants**): the operation succeeds, or refuses cleanly where that is the right answer; each body is one closed shell that passes the record's structure and geometry checks and SMLib's own check; the expected face, edge and vertex counts. Never a kernel's output, and never a commercial kernel's.\n\nThe cases run on SMLib, SolidCraft's kernel. A failing case stays failing until the kernel is fixed; there is no workaround on SolidCraft's side. A failed SMLib call leaves its inputs for replay in the run's output folder (`target/kernel-cases/dumps/<area>-<case>/`). See [`tests/kernel-cases/README.md`](../tests/kernel-cases/README.md) for the format.\n\n",
);
if kernel != "smlib" {
md += &format!("**This run: `SOLIDCRAFT_KERNEL={kernel}`.**\n\n");
md += &format!("**This run: `{env}`.**\n\n");
}
md += "## Coverage\n\n| Area | Cases | Results |\n|---|---|---|\n";
for (area, (n, statuses)) in &areas {
@@ -400,7 +462,9 @@ fn seconds(r: &Value) -> Option<f64> {
/// The two backends side by side: per case (area, id) each one's status, time and what went wrong,
/// as JSON, and the Markdown report: a summary, then per area the cases that differ first.
fn side_by_side(smlib: &[Value], solidcore: &[Value]) -> (Value, String) {
/// `labels` name the two sides in the report (`solidcore[boolean]` for routed families); the JSON
/// keys stay `smlib` and `solidcore`.
fn side_by_side(smlib: &[Value], solidcore: &[Value], labels: [&str; 2]) -> (Value, String) {
let key = |r: &Value| (r["area"].as_str().unwrap_or("").to_string(), r["case"].as_str().unwrap_or("").to_string());
let mut pairs: BTreeMap<(String, String), [Option<&Value>; 2]> = BTreeMap::new();
for (k, rs) in [smlib, solidcore].iter().enumerate() {
@@ -428,9 +492,13 @@ fn side_by_side(smlib: &[Value], solidcore: &[Value]) -> (Value, String) {
}
let differ = pairs.len() - agree;
let mut md = String::from(
"# Kernel regression rig: SMLib and solidcore\n\nGenerated by `cargo xtask kernel-cases --kernel both`: every case in [`tests/kernel-cases/`](../tests/kernel-cases/) run on each backend (`SOLIDCRAFT_KERNEL`), graded against its own answer. Times are the commands' own. [`kernel-cases.md`](kernel-cases.md) is the SMLib run in full.\n\n## Summary\n\n| Backend | Pass | Fail | Other | Time (s) |\n|---|---|---|---|---|\n",
"# Kernel regression rig: SMLib and solidcore\n\nGenerated by `cargo xtask kernel-cases --kernel both`: every case in [`tests/kernel-cases/`](../tests/kernel-cases/) run on each backend (`SOLIDCRAFT_KERNEL`), graded against its own answer. Times are the commands' own. [`kernel-cases.md`](kernel-cases.md) is the SMLib run in full.\n\n",
);
for (k, name) in BACKENDS.iter().enumerate() {
if labels[1] != BACKENDS[1] {
md += &format!("**This run: `{}` is SMLib with only those operation families on solidcore (`--route`).**\n\n", labels[1]);
}
md += "## Summary\n\n| Backend | Pass | Fail | Other | Time (s) |\n|---|---|---|---|---|\n";
for (k, name) in labels.iter().enumerate() {
let n = |b: &str| counts[k].get(b).copied().unwrap_or(0);
md += &format!("| {name} | {} | {} | {} | {:.1} |\n", n("pass"), n("fail"), n("other"), times[k]);
}
@@ -445,7 +513,7 @@ fn side_by_side(smlib: &[Value], solidcore: &[Value]) -> (Value, String) {
}
for (area, mut list) in by_area {
list.sort_by_key(|r| (r["agree"].as_bool().unwrap_or(false), r["case"].as_str().unwrap_or("").to_string()));
md += &format!("\n## {area}\n\n| Case | smlib | solidcore | |\n|---|---|---|---|\n");
md += &format!("\n## {area}\n\n| Case | {} | {} | |\n|---|---|---|---|\n", labels[0], labels[1]);
for r in list {
let mark = if r["agree"].as_bool().unwrap_or(false) { "" } else { "**differ**" };
md += &format!("| {} | {} | {} | {mark} |\n", r["case"].as_str().unwrap_or(""), side(&r["smlib"]), side(&r["solidcore"]));
@@ -457,7 +525,7 @@ fn side_by_side(smlib: &[Value], solidcore: &[Value]) -> (Value, String) {
.map(|(k, name)| (name.to_string(), json!({"counts": counts[k], "seconds": times[k]})))
.collect::<serde_json::Map<_, _>>()
.into();
(json!({"summary": summary, "agree": agree, "differ": differ, "cases": rows}), md)
(json!({"labels": labels, "summary": summary, "agree": agree, "differ": differ, "cases": rows}), md)
}
pub fn run(rest: &[&str]) -> Result<(), String> {
@@ -478,17 +546,24 @@ pub fn run(rest: &[&str]) -> Result<(), String> {
let out = o.out_of(kernel);
save_json(&out, "results.json", results)?;
let to = if *kernel == "smlib" { PathBuf::from("docs/kernel-cases.md") } else { out.join("report.md") };
println!("{}", write_report(&dir, &list, results, kernel, &to)?);
let env = o.env(kernel).iter().map(|(k, v)| format!("{k}={v}")).collect::<Vec<_>>().join(" ");
println!("{}", write_report(&dir, &list, results, &o.label(kernel), &env, &to)?);
}
if let [smlib, solidcore] = runs.as_slice() {
let (data, md) = side_by_side(smlib, solidcore);
save_json(&o.out, "backends.json", &data)?;
let labels = [o.label(BACKENDS[0]), o.label(BACKENDS[1])];
let (data, md) = side_by_side(smlib, solidcore, [&labels[0], &labels[1]]);
// Routed runs keep their side by side with their results, so runs don't overwrite each other.
let into = if o.routes.is_empty() { o.out.clone() } else { o.out_of(BACKENDS[1]) };
save_json(&into, "backends.json", &data)?;
if !o.routes.is_empty() {
std::fs::write(into.join("backends.md"), &md).map_err(|e| format!("{}: {e}", into.join("backends.md").display()))?;
}
std::fs::write(root().join("docs/kernel-cases-backends.md"), md).map_err(|e| format!("docs/kernel-cases-backends.md: {e}"))?;
println!(
"kernel-cases: {} agree, {} differ → docs/kernel-cases-backends.md, {}",
data["agree"],
data["differ"],
o.out.join("backends.json").display()
into.join("backends.json").display()
);
}
Ok(())
@@ -505,7 +580,7 @@ mod tests {
let mut hang = json!({"area": "booleans", "case": "b", "status": "hang", "error": "no result after 180 s"});
hang["process_seconds"] = json!(180.0);
let solidcore = [r("booleans", "a", "pass", 0.5), hang, r("shell", "c", "fail", 1.5)];
let (data, md) = side_by_side(&smlib, &solidcore);
let (data, md) = side_by_side(&smlib, &solidcore, ["smlib", "solidcore"]);
assert_eq!((data["agree"].as_u64(), data["differ"].as_u64()), (Some(1), Some(2)));
assert_eq!(data["summary"]["smlib"]["counts"], json!({"pass": 2, "other": 1}));
assert_eq!(data["summary"]["solidcore"]["counts"], json!({"pass": 1, "fail": 1, "other": 1}));
@@ -517,5 +592,45 @@ mod tests {
assert!(pos_b.is_some() && pos_a.is_some() && pos_b < pos_a, "{md}");
assert!(md.contains("| b | pass (2.00 s) | hang (180.00 s) | **differ** |"), "{md}");
assert!(md.contains("3 cases: 1 agree, 2 differ."), "{md}");
let (data, md) = side_by_side(&smlib, &[], ["smlib", "solidcore[boolean,measure]"]);
assert_eq!(data["labels"], json!(["smlib", "solidcore[boolean,measure]"]));
assert!(md.contains("| solidcore[boolean,measure] | 0 | 0 | 3 |") && md.contains("| Case | smlib | solidcore[boolean,measure] | |"), "{md}");
}
/// `--route` moves the named families on the solidcore side only: SMLib with
/// SOLIDCRAFT_KERNEL_ROUTES, labelled and kept in its own folder.
#[test]
fn routes_label_the_solidcore_side_and_keep_its_own_folder() {
let o = options(&["--kernel", "both", "--route", "measure=solidcore, boolean=solidcore", "--out", "/r"], "x").unwrap();
assert_eq!(o.routes, ["measure", "boolean"]);
assert_eq!((o.label("smlib"), o.label("solidcore")), ("smlib".into(), "solidcore[measure,boolean]".into()));
assert_eq!(o.env("smlib"), [("SOLIDCRAFT_KERNEL", "smlib".to_string())]);
assert_eq!(
o.env("solidcore"),
[("SOLIDCRAFT_KERNEL", "smlib".to_string()), ("SOLIDCRAFT_KERNEL_ROUTES", "measure=solidcore,boolean=solidcore".to_string())]
);
assert_eq!((o.out_of("smlib"), o.out_of("solidcore")), (PathBuf::from("/r"), PathBuf::from("/r/solidcore-measure-boolean")));
let plain = options(&["--kernel", "both", "--out", "/r"], "x").unwrap();
assert_eq!((plain.label("solidcore"), plain.out_of("solidcore")), ("solidcore".into(), PathBuf::from("/r/solidcore")));
assert_eq!(plain.env("solidcore"), [("SOLIDCRAFT_KERNEL", "solidcore".to_string())]);
for bad in [
&["--kernel", "both", "--route", "truck=solidcore"][..],
&["--kernel", "both", "--route", "file=solidcore"],
&["--kernel", "both", "--route", "boolean=smlib"],
&["--kernel", "both", "--route", "boolean"],
&["--kernel", "both", "--route", ""],
&["--kernel", "both", "--route"],
&["--route", "boolean=solidcore"],
] {
assert!(options(bad, "x").is_err(), "{bad:?}");
}
}
/// `--route` knows the families route.rs routes, `file` aside.
#[test]
fn route_ops_are_the_routing_tables_families() {
let text = std::fs::read_to_string(root().join("crates/smlib/src/route.rs")).unwrap_or_default();
let ids: Vec<&str> = text.lines().filter_map(|l| l.trim().strip_prefix("Op::")?.split_once(" => \"")?.1.strip_suffix("\",")).collect();
assert_eq!(ids.iter().filter(|id| **id != "file").copied().collect::<Vec<_>>(), ROUTE_OPS, "{ids:?}");
}
}
+5 -1
View File
@@ -47,7 +47,7 @@ commands:
replay the reference tests (tests/oracle/*/recipe.json), compare with each
case's expected.json and write docs/oracle.md (--cli: a solidcraft-cli
already built, instead of cargo run --release)
kernel-cases [--area AREA] [--cli BIN] [--timeout S] [--jobs N] [--out DIR] [--kernel K]
kernel-cases [--area AREA] [--cli BIN] [--timeout S] [--jobs N] [--out DIR] [--kernel K] [--route R]
the kernel regression rig: run every case in tests/kernel-cases/<area>/<id>/ on
SMLib (one process each, killed after --timeout, default 180 s), grade it against
the case's own answer and write docs/kernel-cases.md; DIR (default
@@ -57,6 +57,10 @@ commands:
solidcore keeps results.json, dumps/ and report.md in DIR/solidcore/ (not
docs/kernel-cases.md); both runs each case on each, and also writes the side by
side to docs/kernel-cases-backends.md and DIR/backends.json
--route OP=solidcore[,...] (with --kernel solidcore|both): the solidcore side is
SMLib with only those families on solidcore (SOLIDCRAFT_KERNEL=smlib plus
SOLIDCRAFT_KERNEL_ROUTES), labelled solidcore[OP,...], into
DIR/solidcore-OP[-OP...]/ with its backends.json and backends.md
--ladder [--record REASON]: the complexity ladder instead
(tests/kernel-cases/ladder/ladder.json, tiers in order), graded and compared
with its timing golden (one case at a time unless --jobs), into