Changed: Optimizes flip algorithm for improved performance

Refactors the flip algorithm to use more efficient data structures
(SmallBuffer instead of FastHashMap/Vec) and hashing techniques
(hash-only dedup) to improve performance. Also refactors benchmark
seed search to avoid `std::process::exit`. These changes significantly
reduce the time spent in the flip algorithm, leading to faster
triangulation construction. (internal)

Refs: perf/optimize-flips

Author: acgetchell

Cargo.lock

@@ -22,16 +22,14 @@ derive_builder = "0.20.2"
 la-stack = "0.1.3"
 tracing = "0.1.44"
 rustc-hash = "2.1.1" # Fast non-cryptographic hashing for performance
-smallvec = { version = "1.15.1", features = [
-    "serde",
-] } # Stack allocation for small collections
+smallvec = { version = "1.15.1", features = [ "serde" ] } # Stack allocation for small collections
 num-traits = "0.2.19"
 ordered-float = { version = "5.1.0", features = [ "serde" ] }
 rand = "0.10.0"
 serde = { version = "1.0.228", features = [ "derive" ] }
 slotmap = { version = "1.1.1", features = [ "serde" ] }
 thiserror = "2.0.18"
-uuid = { version = "1.20.0", features = [ "v4", "serde" ] }
+uuid = { version = "1.20.0", features = [ "v4", "serde", "fast-rng" ] }
 
 [dev-dependencies]
 approx = "0.5.1"

Cargo.toml

@@ -25,9 +25,8 @@
 //! - 3D-5D: Higher-dimensional triangulations as documented in README.md
 
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
-use delaunay::core::delaunay_triangulation::{ConstructionOptions, RetryPolicy};
 use delaunay::geometry::util::generate_random_points_seeded;
-use delaunay::prelude::DelaunayTriangulation;
+use delaunay::prelude::{ConstructionOptions, DelaunayTriangulation, RetryPolicy};
 use delaunay::vertex;
 use std::hint::black_box;
 use std::num::NonZeroUsize;
@@ -70,6 +69,88 @@ macro_rules! benchmark_tds_new_dimension {
         )]
         fn $func_name(c: &mut Criterion) {
             let counts = COUNTS;
+
+            // Opt-in helper for discovering stable seeds without paying Criterion warmup/
+            // measurement cost per seed.
+            //
+            // NOTE: This helper is intentionally per (dim, count) benchmark case.
+            // It returns early on the first successful seed (and panics on failure),
+            // so it is meant to be run with a Criterion filter that selects a single
+            // case, for example:
+            //
+            //     cargo bench --bench ci_performance_suite -- 'tds_new_3d/tds_new/50'
+            //
+            // Because the base seed is derived from `count`, a seed that works for one
+            // count may still fail for a different count.
+            //
+            // We avoid `std::process::exit` here so that destructors run and Criterion
+            // can clean up state on both success and failure.
+            if bench_seed_search_enabled() {
+                let bounds = (-100.0, 100.0);
+                let filters: Vec<String> = std::env::args()
+                    .skip(1)
+                    .filter(|arg| !arg.starts_with('-'))
+                    .collect();
+
+                for &count in counts {
+                    let bench_id =
+                        format!("tds_new_{}d/tds_new/{}", stringify!($dim), count);
+
+                    if !filters.is_empty() && !filters.iter().any(|filter| bench_id.contains(filter)) {
+                        continue;
+                    }
+
+                    let seed = ($seed as u64).wrapping_add(count as u64);
+                    let limit = bench_seed_search_limit();
+
+                    for offset in 0..limit {
+                        let candidate_seed = seed.wrapping_add(offset as u64);
+                        let points = generate_random_points_seeded::<f64, $dim>(
+                            count,
+                            bounds,
+                            candidate_seed,
+                        )
+                        .expect(concat!(
+                            "generate_random_points_seeded failed for ",
+                            stringify!($dim),
+                            "D"
+                        ));
+                        let vertices = points.iter().map(|p| vertex!(*p)).collect::<Vec<_>>();
+
+                        let options =
+                            ConstructionOptions::default().with_retry_policy(RetryPolicy::Shuffled {
+                                attempts: NonZeroUsize::new(6)
+                                    .expect("retry attempts must be non-zero"),
+                                base_seed: Some(candidate_seed),
+                            });
+
+                        if DelaunayTriangulation::<_, (), (), $dim>::new_with_options(
+                            &vertices,
+                            options,
+                        )
+                        .is_ok()
+                        {
+                            println!(
+                                "seed_search_found dim={} count={} seed={}",
+                                $dim, count, candidate_seed
+                            );
+                            return;
+                        }
+                    }
+
+                    panic!(
+                        "seed_search_failed dim={} count={} start_seed={} limit={}",
+                        $dim,
+                        count,
+                        seed,
+                        limit
+                    );
+                }
+
+                // No filter matched this benchmark function; do nothing.
+                return;
+            }
+
             let mut group = c.benchmark_group(concat!("tds_new_", stringify!($dim), "d"));
 
             // Set smaller sample sizes for higher dimensions to keep CI times reasonable
@@ -92,65 +173,6 @@ macro_rules! benchmark_tds_new_dimension {
                     let bounds = (-100.0, 100.0);
                     let seed = ($seed as u64).wrapping_add(count as u64);
 
-                    // Opt-in helper for discovering stable seeds without paying Criterion warmup/
-                    // measurement cost per seed.
-                    //
-                    // NOTE: This helper is intentionally per (dim, count) benchmark case.
-                    // It `exit(0)`s on the first successful seed (and `exit(1)`s on failure),
-                    // so it is meant to be run with a Criterion filter that selects a single
-                    // case, for example:
-                    //
-                    //     cargo bench --bench ci_performance_suite -- 'tds_new_3d/tds_new/50'
-                    //
-                    // Because the base seed is derived from `count`, a seed that works for one
-                    // count may still fail for a different count.
-                    if bench_seed_search_enabled() {
-                        let limit = bench_seed_search_limit();
-                        for offset in 0..limit {
-                            let candidate_seed = seed.wrapping_add(offset as u64);
-                            let points = generate_random_points_seeded::<f64, $dim>(
-                                count,
-                                bounds,
-                                candidate_seed,
-                            )
-                            .expect(concat!(
-                                "generate_random_points_seeded failed for ",
-                                stringify!($dim),
-                                "D"
-                            ));
-                            let vertices = points.iter().map(|p| vertex!(*p)).collect::<Vec<_>>();
-
-                            let options =
-                                ConstructionOptions::default().with_retry_policy(RetryPolicy::Shuffled {
-                                    attempts: NonZeroUsize::new(6)
-                                        .expect("retry attempts must be non-zero"),
-                                    base_seed: Some(candidate_seed),
-                                });
-
-                            if DelaunayTriangulation::<_, (), (), $dim>::new_with_options(
-                                &vertices,
-                                options,
-                            )
-                            .is_ok()
-                            {
-                                println!(
-                                    "seed_search_found dim={} count={} seed={}",
-                                    $dim, count, candidate_seed
-                                );
-                                std::process::exit(0);
-                            }
-                        }
-
-                        println!(
-                            "seed_search_failed dim={} count={} start_seed={} limit={}",
-                            $dim,
-                            count,
-                            seed,
-                            limit
-                        );
-                        std::process::exit(1);
-                    }
-
                     let points = generate_random_points_seeded::<f64, $dim>(count, bounds, seed)
                         .expect(concat!(
                             "generate_random_points_seeded failed for ",

benches/ci_performance_suite.rs

@@ -1700,8 +1700,10 @@ where
         return Err(FlipError::InvalidRidgeMultiplicity { found: cells.len() });
     }
 
-    let mut opposite_counts: FastHashMap<VertexKey, usize> = FastHashMap::default();
-    let mut extras_per_cell: Vec<[VertexKey; 2]> = Vec::with_capacity(3);
+    // k=3 flip contexts are tiny (exactly 3 cells, with 2 "extra" vertices per cell).
+    // Use flat buffers + linear counting to avoid HashMap/Vec overhead in this hot path.
+    let mut opposite_counts: SmallBuffer<(VertexKey, u8), 3> = SmallBuffer::new();
+    let mut extras_per_cell: SmallBuffer<[VertexKey; 2], 3> = SmallBuffer::new();
 
     for &ck in &cells {
         let cell = tds
@@ -1712,22 +1714,28 @@ where
             return Err(FlipError::InvalidRidgeAdjacency { cell_key: ck });
         }
 
-        for &v in &extras {
-            *opposite_counts.entry(v).or_insert(0) += 1;
-        }
         let extras_pair: [VertexKey; 2] = extras
             .as_slice()
             .try_into()
             .map_err(|_| FlipError::InvalidRidgeAdjacency { cell_key: ck })?;
+
+        for &v in &extras_pair {
+            if let Some((_key, count)) = opposite_counts.iter_mut().find(|(key, _)| *key == v) {
+                *count += 1;
+            } else {
+                opposite_counts.push((v, 1));
+            }
+        }
+
         extras_per_cell.push(extras_pair);
     }
 
-    if opposite_counts.len() != 3 || !opposite_counts.values().all(|&count| count == 2) {
+    if opposite_counts.len() != 3 || !opposite_counts.iter().all(|(_v, count)| *count == 2) {
         return Err(FlipError::InvalidRidgeAdjacency { cell_key });
     }
 
     let mut opposite_vertices: SmallBuffer<VertexKey, 3> =
-        opposite_counts.keys().copied().collect();
+        opposite_counts.iter().map(|(v, _count)| *v).collect();
     opposite_vertices.sort_unstable();
     let opposite_vertices: [VertexKey; 3] = opposite_vertices
         .as_slice()
@@ -3801,6 +3809,8 @@ where
                 continue;
             }
 
+            // Intentional hash-only dedup (no vertex-level tie-break): a 64-bit collision is
+            // astronomically unlikely, and avoiding extra comparisons keeps this hot path fast.
             if candidate_facet_info
                 .iter()
                 .any(|(hash, _info)| *hash == facet_hash)
@@ -3871,6 +3881,7 @@ where
             }
             let facet_hash = stable_hash_u64_slice(&facet_values);
 
+            // Hash-only lookup (see comment above); collision risk is astronomically low.
             let Ok(idx) =
                 candidate_facet_info.binary_search_by_key(&facet_hash, |(hash, _info)| *hash)
             else {

src/core/algorithms/flips.rs

@@ -196,11 +196,11 @@ pub(crate) fn matrix_set<const D: usize>(m: &mut Matrix<D>, r: usize, c: usize,
 /// use delaunay::geometry::matrix::{determinant, Matrix};
 ///
 /// let m = Matrix::<2>::zero();
-/// assert_eq!(determinant(m), 0.0);
+/// assert_eq!(determinant(&m), 0.0);
 /// ```
 #[inline]
 #[must_use]
-pub fn determinant<const D: usize>(m: Matrix<D>) -> f64 {
+pub fn determinant<const D: usize>(m: &Matrix<D>) -> f64 {
     match m.det(0.0) {
         Ok(det) => det,
         Err(LaError::Singular { .. }) => 0.0,

src/geometry/matrix.rs

@@ -163,7 +163,7 @@ where
         let tolerance_f64 = crate::geometry::matrix::adaptive_tolerance(&matrix, base_tol);
 
         // Calculate determinant (singular => 0; non-finite => NaN).
-        let det = determinant(matrix);
+        let det = determinant(&matrix);
 
         if det > tolerance_f64 {
             Ok(Orientation::POSITIVE)
@@ -423,7 +423,7 @@ where
         let base_tol = safe_scalar_to_f64(T::default_tolerance())?;
         let tolerance_f64 = crate::geometry::matrix::adaptive_tolerance(&matrix, base_tol);
 
-        let det = determinant(matrix);
+        let det = determinant(&matrix);
         let orientation = simplex_orientation(simplex_points)?;
 
         match orientation {
@@ -626,7 +626,7 @@ where
         let tolerance_f64: f64 = crate::geometry::matrix::adaptive_tolerance(&matrix, base_tol);
 
         // Calculate determinant (singular => 0; non-finite => NaN).
-        let det = determinant(matrix);
+        let det = determinant(&matrix);
 
         // The sign interpretation depends on both orientation and dimension parity
         // For the lifted matrix formulation, even and odd dimensions have opposite sign conventions

src/geometry/predicates.rs

@@ -282,7 +282,7 @@ where
         fill_insphere_predicate_matrix(&mut matrix, simplex_points, test_point)?;
 
         let tol_f64 = crate::geometry::matrix::adaptive_tolerance(&matrix, base_tol);
-        let det = determinant(matrix);
+        let det = determinant(&matrix);
 
         Ok::<(f64, f64), CoordinateConversionError>((det, tol_f64))
     })?;
@@ -342,7 +342,7 @@ where
         }
 
         // Determinant with scale correction.
-        let det = determinant(matrix) * scale_factor;
+        let det = determinant(&matrix) * scale_factor;
 
         Ok::<(f64, f64), CoordinateConversionError>((det, tolerance_raw))
     })?;
@@ -445,7 +445,7 @@ where
         let tolerance_f64: f64 = crate::geometry::matrix::adaptive_tolerance(&matrix, base_tol);
 
         // Calculate determinant (singular => 0; non-finite => NaN).
-        let det = determinant(matrix);
+        let det = determinant(&matrix);
 
         if det > tolerance_f64 {
             Ok(Orientation::POSITIVE)

src/geometry/robust_predicates.rs

@@ -963,7 +963,7 @@ fn build_and_analyze_matrix(simplex_vertices: &[Vertex<f64, i32, 3>]) -> (f64, b
         );
     }
 
-    let det = determinant(matrix);
+    let det = determinant(&matrix);
     println!();
     println!("Determinant: {det:.6}");