pre-size the pagoda parallel filter instead of growing via push

A profile with symbols/frame-pointers preserved and LTO disabled
(RUSTFLAGS="-C target-cpu=native -C force-frame-pointers=yes",
CARGO_PROFILE_RELEASE_{STRIP,DEBUG,LTO} overridden for the build - the
committed profile strips symbols and enables thin LTO, both of which
make perf traces hard to trust: stripped binaries collapse everything
into one opaque module frame, and LTO's cross-crate inlining can
misattribute samples to the wrong function) showed finish_grow as a
real, avoidable cost in the two par::parallel(...).filter(...).collect()
calls added for pagoda pruning: each chunk's output Vec grew via
repeated reallocation as matches were found, instead of being sized
once up front - the same category of fix already applied in
board.rs's possible_moves/possible_reverse_moves and keyset.rs's
extraction.

Added par::par_filter, a parallel filter that counts matches per
chunk first (cheap now that pagoda() is O(1)) and allocates each
chunk's buffer at its exact final size. Re-profiled the same way
after the fix: finish_grow no longer appears in the profile at all.

Wall-clock effect (hyperfine, native-cpu build, 50 runs): pagoda
pruning is now genuinely neutral rather than a net loss (mean ratio
1.00 +/- 0.03 vs the pre-pagoda commit) - correctness-preserving and
essentially free, even though it doesn't deliver a net win on this
implementation's current bottleneck (see the previous commit).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: feschber

solitaire-solver/src/feasible.rs

@@ -281,8 +281,8 @@ pub fn calculate_feasible_set(threads: Option<NonZero<usize>>) -> Vec<Board> {
         // filter instead of Vec::retain (single-threaded) - up to ~2.6M elements
         // on the biggest rounds is enough for that gap to matter on its own.
         let solved_weight = crate::pagoda::pagoda(Board::solved());
-        let constellations = par::parallel(&constellations, threads, |chunk| {
-            chunk.iter().copied().filter(|&b| crate::pagoda::pagoda(b.inverse()) >= solved_weight).collect()
+        let constellations = par::par_filter(&constellations, threads, |&b| {
+            crate::pagoda::pagoda(b.inverse()) >= solved_weight
         });
 
         let deduped = constellations.len();
@@ -347,8 +347,8 @@ pub fn calculate_feasible_set(threads: Option<NonZero<usize>>) -> Vec<Board> {
             // Parallel filter instead of Vec::retain (single-threaded) - this is
             // exactly the biggest round in the whole algorithm, up to ~3M elements.
             let solved_weight = crate::pagoda::pagoda(Board::solved());
-            let constellations = par::parallel(&constellations, threads, |chunk| {
-                chunk.iter().copied().filter(|&b| crate::pagoda::pagoda(b) >= solved_weight).collect()
+            let constellations = par::par_filter(&constellations, threads, |&b| {
+                crate::pagoda::pagoda(b) >= solved_weight
             });
             let deduped = constellations.len();
 

solitaire-solver/src/par.rs

@@ -96,6 +96,27 @@ where
     par_join(&par_map_chunks(states, nthreads, f))
 }
 
+/// filters `items` in parallel, pre-sizing each chunk's output buffer exactly
+/// once instead of growing it via repeated reallocation as matches are found -
+/// same reasoning as the capacity precounting already used in `board.rs`'s
+/// `possible_moves`/`possible_reverse_moves` and `keyset.rs`'s extraction: a
+/// plain `chunk.iter().filter(pred).collect()` per chunk showed up as real,
+/// avoidable allocator cost (`finish_grow`) once `pred` got cheap enough that
+/// the buffer growth was no longer negligible next to it.
+pub(crate) fn par_filter<T, F>(items: &[T], nthreads: usize, pred: F) -> Vec<T>
+where
+    T: Copy + Send + Sync,
+    F: Fn(&T) -> bool + Send + Sync,
+{
+    let chunks: Vec<Vec<T>> = par_map_chunks(items, nthreads, |chunk| {
+        let count = chunk.iter().filter(|x| pred(x)).count();
+        let mut out = Vec::with_capacity(count);
+        out.extend(chunk.iter().copied().filter(|x| pred(x)));
+        out
+    });
+    par_join(&chunks)
+}
+
 pub(crate) trait ParDedup {
     fn par_dedup(self, n_threads: usize) -> Self;
 }