Sketch: use a lookup map for curves in pattern upkeep (#10524)

* claim: Sketch: use a lookup map for curves in pattern upkeep

* Sketch: use a lookup map for curves in pattern upkeep

Pattern upkeep runs before every solve, each drag frame included, and
looked up every copy curve and its arc points with a linear search over
all ids. Dragging another line in a sketch with a 500-copy slot pattern
spent about two thirds of each frame there. The ids now resolve through
maps built once per call; the result is the same to the bit.

The solve bench gains a circular slot pattern section.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Markus Kaltenbrunner <kaltenbrunnermarkus@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
authored and GitHub committed 2026-11-01 09:16:59 +00:00
1 parent ce72abacf9
commit 71624cf7fa
4 files changed
+129 -9

No files matched your search

+55 -1
View File
@@ -6,7 +6,9 @@
use std::time::Instant;
use solidcraft_geom::Vec2;
use solidcraft_sketch::{Analysis, Budget, ConstraintKind, Hold, Sketch, SolveReport, solve, solve_with};
use solidcraft_sketch::{
Analysis, Budget, ConstraintKind, Hold, PatternAlignment, Sketch, SketchPattern, SketchPatternKind, SolveReport, solve, solve_with,
};
/// A small deterministic generator for the start offsets.
struct Lcg(u64);
@@ -66,6 +68,33 @@ fn strip(n: usize) -> Result<(Sketch, usize), Box<dyn std::error::Error>> {
Ok((sk, bottom[0]))
}
/// A slot (two arcs joined by two lines) copied `count` times around the origin by a circular
/// pattern. Returns the sketch and the seed's first arc start point.
fn slot_pattern(count: usize) -> Result<(Sketch, usize), Box<dyn std::error::Error>> {
let mut sk = Sketch::new();
let center = sk.add_point(Vec2::ZERO, None)?;
sk.add_constraint(ConstraintKind::Fix { p: center }, None)?;
let (c0, c1) = (Vec2::new(200.0, 0.0), Vec2::new(210.0, 0.0));
let p = [c0 + Vec2::new(0.0, -2.0), c0 + Vec2::new(0.0, 2.0), c1 + Vec2::new(0.0, -2.0), c1 + Vec2::new(0.0, 2.0)];
let pts: Vec<usize> = p.iter().map(|q| sk.add_point(*q, None)).collect::<Result<_, _>>()?;
let left = sk.add_arc(c0, p[1], p[0], [None, Some(pts[1]), Some(pts[0])], None)?;
let right = sk.add_arc(c1, p[2], p[3], [None, Some(pts[2]), Some(pts[3])], None)?;
let bottom = sk.add_line_pts(pts[0], pts[2], None)?;
let top = sk.add_line_pts(pts[1], pts[3], None)?;
let entities = [left, right, bottom, top].iter().filter_map(|i| sk.curves.get(*i).map(|c| c.id.clone())).collect();
let center_id = sk.points.get(center).map(|q| q.id.clone()).ok_or("missing center")?;
let kind = SketchPatternKind::Circular { center: center_id, count, angle: 360.0, alignment: PatternAlignment::Right, reversed: false };
let id = sk.fresh("pat")?;
sk.patterns.push(SketchPattern { id, entities, kind: kind.clone(), count_expression: None, instances: vec![], expressions: Default::default() });
sk.update_pattern(0, kind)?;
Ok((sk, pts[1]))
}
/// A hash of the whole sketch, every number to the bit, to compare solver output between builds.
fn fingerprint(sk: &Sketch) -> u64 {
format!("{sk:?}").bytes().fold(0xcbf29ce484222325, |h, b| (h ^ u64::from(b)).wrapping_mul(0x100000001b3))
}
/// Best of `reps` solves of a copy of `sk` (ms) and the last report.
fn time(sk: &Sketch, reps: usize, f: impl Fn(&mut Sketch) -> SolveReport) -> (f64, SolveReport) {
let mut best = f64::MAX;
@@ -104,5 +133,30 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let (full, _) = time(&sk, 5, solve);
println!("| {n} rectangles | {} | {frame:.2} ({:?}) | {full:.2} |", sk.points.len(), rep.status);
}
println!();
println!("| circular slot pattern | curves | points | drag frame on another line ms | drag frame on the seed ms | output |");
println!("|---|---|---|---|---|---|");
for count in [100usize, 500] {
let (mut sk, seed) = slot_pattern(count)?;
let a = sk.add_point(Vec2::new(-500.0, -500.0), None)?;
let b = sk.add_point(Vec2::new(-480.0, -500.0), None)?;
let l = sk.add_line_pts(a, b, None)?;
sk.add_constraint(ConstraintKind::Horizontal { l }, None)?;
let drag = |point: usize| -> (f64, u64) {
let mut start = sk.clone();
if let Some(p) = start.points.get_mut(point) {
p.pos += Vec2::new(0.5, 0.3);
}
let hold = Hold { points: vec![point], radii: vec![] };
let frame = |k: &mut Sketch| solve_with(k, &hold, None, Analysis::StatusOnly, Some(&mut Budget::frame()));
let (ms, _) = time(&start, 5, frame);
frame(&mut start);
(ms, fingerprint(&start))
};
let (other, other_out) = drag(b);
// Solving the whole pattern takes seconds at 500 copies.
let (on_seed, seed_out) = if count <= 100 { drag(seed) } else { (f64::NAN, 0) };
println!("| {count} slots | {} | {} | {other:.2} | {on_seed:.2} | {other_out:016x} {seed_out:016x} |", sk.curves.len(), sk.points.len());
}
Ok(())
}
+4
View File
@@ -827,9 +827,13 @@ impl Sketch {
}
pub fn point_index(&self, id: &str) -> Option<usize> {
#[cfg(test)]
crate::tests::count_id_search();
self.points.iter().position(|p| p.id == id)
}
pub fn curve_index(&self, id: &str) -> Option<usize> {
#[cfg(test)]
crate::tests::count_id_search();
self.curves.iter().position(|c| c.id == id)
}
pub fn point(&self, i: usize) -> Option<Vec2> {
+33 -8
View File
@@ -334,15 +334,31 @@ impl Sketch {
/// Conic rho is an authored shape parameter rather than a solver unknown. Like its
/// defining points, the copies follow the seed's shape when that parameter is edited.
pub(crate) fn refresh_pattern_shapes(&mut self) {
if !self.curves.iter().any(|c| matches!(c.kind, CurveKind::Conic { .. } | CurveKind::Arc { .. })) {
if self.patterns.is_empty() || !self.curves.iter().any(|c| matches!(c.kind, CurveKind::Conic { .. } | CurveKind::Arc { .. })) {
return;
}
for pattern in &self.patterns {
let sources: Vec<_> = pattern.entities.iter().filter_map(|id| self.curve_index(id)).collect();
for instance in &pattern.instances {
for (seed, copy) in sources.iter().zip(&instance.curves) {
// This runs before every solve, drag frames included. Ids resolve through maps built
// once here: a linear search per copy cost patterns × copies × seeds × curves string
// comparisons, which dominated dragging anything in a sketch with a large pattern.
// Only curve shapes change below, so the indices stay valid throughout.
let (sources, copies): (Vec<Vec<usize>>, Vec<Vec<Vec<Option<usize>>>>) = {
let curves = first_index(self.curves.iter().map(|c| c.id.as_str()));
self.patterns
.iter()
.map(|pattern| {
(
pattern.entities.iter().filter_map(|id| curves.get(id.as_str()).copied()).collect(),
pattern.instances.iter().map(|i| i.curves.iter().map(|id| curves.get(id.as_str()).copied()).collect()).collect(),
)
})
.unzip()
};
let points = first_index(self.points.iter().map(|p| p.id.as_str()));
for ((pattern, sources), copies) in self.patterns.iter().zip(&sources).zip(&copies) {
for (instance, copies) in pattern.instances.iter().zip(copies) {
for (seed, copy) in sources.iter().zip(copies) {
if let Some(CurveKind::Conic { rho, .. }) = self.curves.get(*seed).map(|c| &c.kind)
&& let Some(copy) = self.curve_index(copy)
&& let Some(copy) = *copy
{
let rho = *rho;
if let Some(CurveKind::Conic { rho: slot, .. }) = self.curves.get_mut(copy).map(|c| &mut c.kind) {
@@ -355,9 +371,9 @@ impl Sketch {
self.points
.get(p)
.and_then(|p| instance.points.iter().find(|(id, _)| *id == p.id))
.and_then(|(_, id)| self.point_index(id))
.and_then(|(_, id)| points.get(id.as_str()).copied())
};
if let (Some(c), Some(a), Some(b), Some(copy)) = (mapped(c), mapped(a), mapped(b), self.curve_index(copy))
if let (Some(c), Some(a), Some(b), Some(copy)) = (mapped(c), mapped(a), mapped(b), *copy)
&& let Some(curve) = self.curves.get_mut(copy)
{
curve.kind = CurveKind::Arc { c, a, b };
@@ -561,3 +577,12 @@ fn rotate(c: Vec2, ang: f64) -> impl Fn(Vec2) -> Vec2 {
c + Vec2::new(d.x * co - d.y * s, d.x * s + d.y * co)
}
}
/// Each id's first index, as `position` finds it.
fn first_index<'a>(ids: impl Iterator<Item = &'a str>) -> std::collections::HashMap<&'a str, usize> {
let mut map = std::collections::HashMap::new();
for (i, id) in ids.enumerate() {
map.entry(id).or_insert(i);
}
map
}
+37
View File
@@ -25,6 +25,15 @@ impl Lcg {
}
}
thread_local! {
static ID_SEARCHES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// A linear search for a point or curve by id on this thread.
pub(crate) fn count_id_search() {
ID_SEARCHES.with(|c| c.set(c.get() + 1));
}
/// Run `f` with the constructive seed on or off, without the seed-on/seed-off comparison (for
/// tests that measure the difference).
pub(crate) fn seeded<T>(on: bool, f: impl FnOnce() -> T) -> T {
@@ -1471,3 +1480,31 @@ fn a_held_solve_that_cannot_succeed_stops_once_it_stalls() {
// A solve whose report names the violated constraints still iterates to the end.
assert!(solve(Analysis::Full) >= 500);
}
/// Pattern upkeep runs before every solve, each drag frame included. It once looked up every
/// copy and its arc points by a linear search over all ids, so dragging anything in a sketch
/// with a large pattern of arcs spent most of each frame there; its searches must not grow
/// with the copies. The copies still follow their seed's arc direction.
#[test]
fn pattern_upkeep_does_not_search_ids_per_copy() {
let mut sk = Sketch::new();
let center = sk.add_point(v(0.0, 0.0), None).unwrap();
let arc = sk.add_arc(v(20.0, 0.0), v(23.0, 0.0), v(20.0, 3.0), [None, None, None], None).unwrap();
let entities = vec![sk.curves[arc].id.clone()];
let kind = SketchPatternKind::Circular {
center: sk.points[center].id.clone(),
count: 50,
angle: 360.0,
alignment: PatternAlignment::Right,
reversed: false,
};
let id = sk.fresh("pat").unwrap();
sk.patterns.push(SketchPattern { id, entities, kind: kind.clone(), count_expression: None, instances: vec![], expressions: Default::default() });
sk.update_pattern(0, kind).unwrap();
assert_eq!(sk.curves.len(), 50);
sk.curves[arc].reversed = true;
ID_SEARCHES.with(|c| c.set(0));
sk.refresh_pattern_shapes();
assert_eq!(ID_SEARCHES.with(std::cell::Cell::get), 0, "id searches in pattern upkeep");
assert!(sk.curves.iter().all(|c| c.reversed));
}