@feltdb/core 0.4.12 → 0.4.14

package/dist/create/server-source/crates/feltdb/benches/phase_7_1_2_optimization_benchmark.rs

@@ -0,0 +1,383 @@
+/// Phase 7.1.2: Optimization Benchmark & Regression Gate
+///
+/// Proves three things independently:
+/// 1. The optimized release path is materially faster
+/// 2. The speedup comes from reducing candidate examination (causal evidence)
+/// 3. The optimization doesn't create a new bottleneck elsewhere
+///
+/// Key principle: Don't declare victory from a microbenchmark.
+/// Systematically measure: latency, examination counts, memory, concurrency.
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
+use feltdb::causal_dependency_barrier::CausalDependencyBarrier;
+use feltdb::convergence::VectorClock;
+
+/// Benchmark workload configuration
+#[derive(Clone, Debug)]
+struct BenchmarkWorkload {
+    pending_size: usize,        // 10, 100, 1K, 10K, 100K
+    frontier_advances: usize,   // 1, 10
+    release_selectivity: f64,   // Fraction of operations that will be released
+}
+
+/// Metrics collected during a benchmark run
+#[derive(Clone, Default, Debug)]
+struct ReleaseMetrics {
+    // Reference implementation
+    ref_pending_examined: u64,
+    ref_operations_released: u64,
+    ref_readiness_checks: u64,
+    ref_latency_ns: u64,
+
+    // Optimized implementation
+    opt_candidates_discovered: u64,
+    opt_candidates_examined: u64,
+    opt_operations_released: u64,
+    opt_readiness_checks: u64,
+    opt_latency_ns: u64,
+
+    // Index maintenance
+    opt_index_entries: u64,
+}
+
+impl ReleaseMetrics {
+    /// Calculate candidate reduction percentage
+    fn candidate_reduction_pct(&self) -> f64 {
+        if self.ref_pending_examined == 0 {
+            0.0
+        } else {
+            (1.0 - (self.opt_candidates_examined as f64 / self.ref_pending_examined as f64))
+                * 100.0
+        }
+    }
+
+    /// Calculate speedup ratio
+    fn speedup_ratio(&self) -> f64 {
+        if self.opt_latency_ns == 0 {
+            0.0
+        } else {
+            self.ref_latency_ns as f64 / self.opt_latency_ns as f64
+        }
+    }
+}
+
+/// Generate a benchmark workload with reproducible randomness
+fn generate_workload(workload: &BenchmarkWorkload, seed: u64) -> (Vec<(String, VectorClock)>, Vec<VectorClock>) {
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
+
+    let mut hasher = DefaultHasher::new();
+    seed.hash(&mut hasher);
+    let mut rng_seed = hasher.finish();
+
+    fn next_rng(seed: &mut u64) -> u64 {
+        *seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        *seed
+    }
+
+    // Generate pending operations
+    let mut operations = Vec::new();
+    let node_count = 5; // Fixed for consistency
+
+    for i in 0..workload.pending_size {
+        let mut required = VectorClock::new();
+        // Create dependency that will be satisfied based on selectivity
+        let release_threshold = (workload.pending_size as f64 * workload.release_selectivity) as usize;
+        let ts = if i < release_threshold {
+            10 // Will be released when frontier advances to 10
+        } else {
+            100 // Will remain pending
+        };
+        required.clocks.insert(format!("node_0"), ts);
+        operations.push((format!("op_{}", i), required));
+    }
+
+    // Generate frontier advances
+    let mut advances = Vec::new();
+    for _ in 0..workload.frontier_advances {
+        let mut frontier = VectorClock::new();
+        frontier.clocks.insert("node_0".to_string(), 10);
+        advances.push(frontier);
+    }
+
+    (operations, advances)
+}
+
+/// Run reference implementation benchmark
+fn benchmark_reference_release(
+    workload: &BenchmarkWorkload,
+    operations: &[(String, VectorClock)],
+    advances: &[VectorClock],
+) -> ReleaseMetrics {
+    let mut barrier = CausalDependencyBarrier::new();
+    let mut metrics = ReleaseMetrics::default();
+
+    // Load operations
+    for (op_id, required) in operations {
+        barrier.receive_operation(op_id.clone(), required.clone());
+    }
+
+    // Execute advances and measure
+    for advance in advances {
+        barrier.clear_metrics();
+        {
+            let current = barrier.get_frontier().clone();
+            barrier.get_prev_frontier_mut().clone_from(&current);
+        }
+        barrier.get_frontier_mut().merge(advance);
+
+        let start = std::time::Instant::now();
+        let _released = barrier.check_unblocked_operations_full_scan();
+        metrics.ref_latency_ns += start.elapsed().as_nanos() as u64;
+
+        metrics.ref_pending_examined += barrier.get_metrics().pending_entries_examined;
+        metrics.ref_operations_released += barrier.get_metrics().operations_released;
+        metrics.ref_readiness_checks += barrier.get_metrics().frontier_checks;
+    }
+
+    metrics
+}
+
+/// Run optimized implementation benchmark
+fn benchmark_optimized_release(
+    workload: &BenchmarkWorkload,
+    operations: &[(String, VectorClock)],
+    advances: &[VectorClock],
+) -> ReleaseMetrics {
+    let mut barrier = CausalDependencyBarrier::new();
+    let mut metrics = ReleaseMetrics::default();
+
+    // Load operations
+    for (op_id, required) in operations {
+        barrier.receive_operation(op_id.clone(), required.clone());
+    }
+
+    // Execute advances and measure
+    for advance in advances {
+        barrier.clear_metrics();
+        {
+            let current = barrier.get_frontier().clone();
+            barrier.get_prev_frontier_mut().clone_from(&current);
+        }
+        barrier.get_frontier_mut().merge(advance);
+
+        let start = std::time::Instant::now();
+        let _released = barrier.check_unblocked_operations_indexed();
+        metrics.opt_latency_ns += start.elapsed().as_nanos() as u64;
+
+        let barrier_metrics = barrier.get_metrics();
+        metrics.opt_candidates_examined += barrier_metrics.pending_entries_examined;
+        metrics.opt_operations_released += barrier_metrics.operations_released;
+        metrics.opt_readiness_checks += barrier_metrics.frontier_checks;
+
+        // Track index size
+        metrics.opt_index_entries = barrier.get_dependency_index().waiters.len() as u64;
+    }
+
+    metrics
+}
+
+/// Phase 7.1.2 Stage 1: Single-threaded Optimization Benchmark
+fn benchmark_optimization_matrix(c: &mut Criterion) {
+    let mut group = c.benchmark_group("phase_7_1_2_optimization");
+    group.sample_size(10); // Fewer samples for larger workloads
+
+    // Primary matrix: pending × advances × selectivity
+    let pending_sizes = vec![10, 100, 1_000, 10_000];
+    let advance_counts = vec![1, 10];
+    let selectivities = vec![0.10]; // Start with 10% release
+
+    println!("\n=== Phase 7.1.2: Optimization Matrix Metrics ===");
+    println!("{:<8} {:<10} {:<10} {:<15} {:<15} {:<12} {:<12}",
+        "Pending", "Advances", "Selectivity", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %");
+
+    for pending in &pending_sizes {
+        for advances in &advance_counts {
+            for selectivity in &selectivities {
+                let workload = BenchmarkWorkload {
+                    pending_size: *pending,
+                    frontier_advances: *advances,
+                    release_selectivity: *selectivity,
+                };
+
+                let (ops, advs) = generate_workload(&workload, 42);
+                let ref_metrics = benchmark_reference_release(&workload, &ops, &advs);
+                let opt_metrics = benchmark_optimized_release(&workload, &ops, &advs);
+
+                let ref_us = ref_metrics.ref_latency_ns as f64 / 1000.0;
+                let opt_us = opt_metrics.opt_latency_ns as f64 / 1000.0;
+                let speedup = ref_metrics.ref_latency_ns as f64 / opt_metrics.opt_latency_ns as f64;
+                let candidate_reduction = opt_metrics.candidate_reduction_pct();
+
+                println!("{:<8} {:<10} {:<10.0}% {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
+                    pending, advances, selectivity * 100.0, ref_us, opt_us, speedup, candidate_reduction);
+
+                let bench_name = format!("pending_{}_advances_{}_sel_{:.0}pct",
+                    pending, advances, selectivity * 100.0);
+
+                group.bench_with_input(
+                    BenchmarkId::new("reference", &bench_name),
+                    &workload,
+                    |b, w| {
+                        let (ops, advs) = generate_workload(w, 42);
+                        b.iter(|| {
+                            benchmark_reference_release(black_box(w), black_box(&ops), black_box(&advs))
+                        });
+                    },
+                );
+
+                group.bench_with_input(
+                    BenchmarkId::new("optimized", &bench_name),
+                    &workload,
+                    |b, w| {
+                        let (ops, advs) = generate_workload(w, 42);
+                        b.iter(|| {
+                            benchmark_optimized_release(black_box(w), black_box(&ops), black_box(&advs))
+                        });
+                    },
+                );
+            }
+        }
+    }
+
+    group.finish();
+}
+
+/// Phase 7.1.2 Stage 2: Release Selectivity Variation
+fn benchmark_selectivity_variation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("phase_7_1_2_selectivity");
+    group.sample_size(10);
+
+    // Fixed pending size, vary selectivity
+    let pending_size = 1_000;
+    let selectivities = vec![0.0, 0.01, 0.10, 0.25, 0.50, 0.75, 1.0];
+
+    println!("\n=== Phase 7.1.2: Selectivity Variation Metrics ===");
+    println!("{:<12} {:<15} {:<15} {:<12} {:<12}",
+        "Selectivity", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %");
+
+    for selectivity in selectivities {
+        let workload = BenchmarkWorkload {
+            pending_size,
+            frontier_advances: 1,
+            release_selectivity: selectivity,
+        };
+
+        let (ops, advs) = generate_workload(&workload, 42);
+        let ref_metrics = benchmark_reference_release(&workload, &ops, &advs);
+        let opt_metrics = benchmark_optimized_release(&workload, &ops, &advs);
+
+        let ref_us = ref_metrics.ref_latency_ns as f64 / 1000.0;
+        let opt_us = opt_metrics.opt_latency_ns as f64 / 1000.0;
+        let speedup = if opt_metrics.opt_latency_ns > 0 {
+            ref_metrics.ref_latency_ns as f64 / opt_metrics.opt_latency_ns as f64
+        } else {
+            0.0
+        };
+        let candidate_reduction = opt_metrics.candidate_reduction_pct();
+
+        println!("{:<12.0}% {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
+            selectivity * 100.0, ref_us, opt_us, speedup, candidate_reduction);
+
+        let bench_name = format!("pending_1000_sel_{:.0}pct", selectivity * 100.0);
+
+        group.bench_with_input(
+            BenchmarkId::new("reference", &bench_name),
+            &workload,
+            |b, w| {
+                let (ops, advs) = generate_workload(w, 42);
+                b.iter(|| {
+                    benchmark_reference_release(black_box(w), black_box(&ops), black_box(&advs))
+                });
+            },
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("optimized", &bench_name),
+            &workload,
+            |b, w| {
+                let (ops, advs) = generate_workload(w, 42);
+                b.iter(|| {
+                    benchmark_optimized_release(black_box(w), black_box(&ops), black_box(&advs))
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+/// Phase 7.1.2 Stage 3: Pathological Scaling Case
+/// Previous evidence: 100 pending × 10 advances = 1000 examinations vs 100-200 candidates
+/// Now scale it to see the curve
+fn benchmark_pathological_scaling(c: &mut Criterion) {
+    let mut group = c.benchmark_group("phase_7_1_2_pathological_scaling");
+    group.sample_size(10); // Criterion requires minimum 10 samples
+
+    let pending_sizes = vec![100, 1_000, 10_000];
+    let advance_count = 10;
+    let selectivity = 0.10; // 10% of pending operations become ready each advance
+
+    println!("\n=== Phase 7.1.2: Pathological Scaling (10 advances) ===");
+    println!("{:<10} {:<15} {:<15} {:<12} {:<12}",
+        "Pending", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %");
+
+    for pending in &pending_sizes {
+        let workload = BenchmarkWorkload {
+            pending_size: *pending,
+            frontier_advances: advance_count,
+            release_selectivity: selectivity,
+        };
+
+        let (ops, advs) = generate_workload(&workload, 42);
+        let ref_metrics = benchmark_reference_release(&workload, &ops, &advs);
+        let opt_metrics = benchmark_optimized_release(&workload, &ops, &advs);
+
+        let ref_us = ref_metrics.ref_latency_ns as f64 / 1000.0;
+        let opt_us = opt_metrics.opt_latency_ns as f64 / 1000.0;
+        let speedup = if opt_metrics.opt_latency_ns > 0 {
+            ref_metrics.ref_latency_ns as f64 / opt_metrics.opt_latency_ns as f64
+        } else {
+            0.0
+        };
+        let candidate_reduction = opt_metrics.candidate_reduction_pct();
+
+        println!("{:<10} {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
+            pending, ref_us, opt_us, speedup, candidate_reduction);
+
+        let bench_name = format!("pending_{}_advances_{}", pending, advance_count);
+
+        group.bench_with_input(
+            BenchmarkId::new("reference", &bench_name),
+            &workload,
+            |b, w| {
+                let (ops, advs) = generate_workload(w, 42);
+                b.iter(|| {
+                    benchmark_reference_release(black_box(w), black_box(&ops), black_box(&advs))
+                });
+            },
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("optimized", &bench_name),
+            &workload,
+            |b, w| {
+                let (ops, advs) = generate_workload(w, 42);
+                b.iter(|| {
+                    benchmark_optimized_release(black_box(w), black_box(&ops), black_box(&advs))
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    benchmark_optimization_matrix,
+    benchmark_selectivity_variation,
+    benchmark_pathological_scaling,
+);
+
+criterion_main!(benches);

package/dist/create/server-source/crates/feltdb/benches/phase_7_1_3_crossover_analysis.rs

@@ -0,0 +1,298 @@
+/// Phase 7.1.3: Crossover Analysis & Dispatch Economics
+///
+/// Determines where full_scan vs indexed dispatch should switch.
+///
+/// Measures across the full workload matrix:
+/// - Pending size: 32, 64, 128, 256, 512, 1K, 10K
+/// - Release selectivity: 0%, 1%, 10%, 25%, 50%, 75%, 100%
+/// - Frontier advances: 1, 10, 100
+///
+/// Output: CSV table suitable for crossover curve analysis
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
+use feltdb::causal_dependency_barrier::CausalDependencyBarrier;
+use feltdb::convergence::VectorClock;
+use std::fs::File;
+use std::io::Write;
+
+/// Full workload configuration
+#[derive(Clone, Debug)]
+struct CrossoverWorkload {
+    pending_size: usize,
+    frontier_advances: usize,
+    release_selectivity: f64,
+}
+
+/// Complete measurement record
+#[derive(Clone, Debug)]
+struct CrossoverMetrics {
+    // Scenario
+    pending: usize,
+    advances: usize,
+    selectivity: f64,
+
+    // Full scan path
+    fs_latency_ns: u64,
+    fs_entries_examined: u64,
+    fs_ops_released: u64,
+
+    // Indexed path
+    ix_latency_ns: u64,
+    ix_candidates_discovered: u64,
+    ix_candidates_examined: u64,
+    ix_ops_released: u64,
+    ix_index_entries: u64,
+
+    // Derived
+    speedup: f64,
+    winner: char, // 'F' for full_scan, 'I' for indexed
+}
+
+impl CrossoverMetrics {
+    fn to_csv(&self) -> String {
+        format!(
+            "{},{},{},{},{},{},{},{},{},{},{},{},{},{}",
+            self.pending,
+            self.advances,
+            self.selectivity * 100.0,
+            self.fs_latency_ns,
+            self.fs_entries_examined,
+            self.fs_ops_released,
+            self.ix_latency_ns,
+            self.ix_candidates_discovered,
+            self.ix_candidates_examined,
+            self.ix_ops_released,
+            self.ix_index_entries,
+            self.speedup,
+            self.winner,
+            if self.winner == 'I' { "INDEXED" } else { "FULL_SCAN" }
+        )
+    }
+}
+
+/// Generate reproducible workload
+fn generate_workload(
+    workload: &CrossoverWorkload,
+    seed: u64,
+) -> (Vec<(String, VectorClock)>, Vec<VectorClock>) {
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
+
+    let mut hasher = DefaultHasher::new();
+    seed.hash(&mut hasher);
+    let _rng_seed = hasher.finish();
+
+    // Generate pending operations
+    let mut operations = Vec::new();
+    for i in 0..workload.pending_size {
+        let mut required = VectorClock::new();
+        let release_threshold = (workload.pending_size as f64 * workload.release_selectivity) as usize;
+        let ts = if i < release_threshold {
+            10 // Will be released when frontier advances to 10
+        } else {
+            100 // Will remain pending
+        };
+        required.clocks.insert(format!("node_0"), ts);
+        operations.push((format!("op_{}", i), required));
+    }
+
+    // Generate frontier advances
+    let mut advances = Vec::new();
+    for _ in 0..workload.frontier_advances {
+        let mut frontier = VectorClock::new();
+        frontier.clocks.insert("node_0".to_string(), 10);
+        advances.push(frontier);
+    }
+
+    (operations, advances)
+}
+
+/// Measure full_scan path
+fn measure_full_scan(
+    workload: &CrossoverWorkload,
+    operations: &[(String, VectorClock)],
+    advances: &[VectorClock],
+) -> (u64, u64, u64) {
+    let mut barrier = CausalDependencyBarrier::new();
+    let mut latency_ns = 0u64;
+    let mut entries_examined = 0u64;
+    let mut ops_released = 0u64;
+
+    // Load operations
+    for (op_id, required) in operations {
+        barrier.receive_operation(op_id.clone(), required.clone());
+    }
+
+    // Execute advances and measure
+    for advance in advances {
+        barrier.clear_metrics();
+        {
+            let current = barrier.get_frontier().clone();
+            barrier.get_prev_frontier_mut().clone_from(&current);
+        }
+        barrier.get_frontier_mut().merge(advance);
+
+        let start = std::time::Instant::now();
+        let _released = barrier.check_unblocked_operations_full_scan();
+        latency_ns += start.elapsed().as_nanos() as u64;
+
+        let metrics = barrier.get_metrics();
+        entries_examined += metrics.pending_entries_examined;
+        ops_released += metrics.operations_released;
+    }
+
+    (latency_ns, entries_examined, ops_released)
+}
+
+/// Measure indexed path
+fn measure_indexed(
+    workload: &CrossoverWorkload,
+    operations: &[(String, VectorClock)],
+    advances: &[VectorClock],
+) -> (u64, u64, u64, u64, u64) {
+    let mut barrier = CausalDependencyBarrier::new();
+    let mut latency_ns = 0u64;
+    let mut candidates_discovered = 0u64;
+    let mut candidates_examined = 0u64;
+    let mut ops_released = 0u64;
+
+    // Load operations
+    for (op_id, required) in operations {
+        barrier.receive_operation(op_id.clone(), required.clone());
+    }
+
+    // Execute advances and measure
+    for advance in advances {
+        barrier.clear_metrics();
+        {
+            let current = barrier.get_frontier().clone();
+            barrier.get_prev_frontier_mut().clone_from(&current);
+        }
+        barrier.get_frontier_mut().merge(advance);
+
+        // Track candidates before
+        let index_before = barrier.get_dependency_index().waiters.len() as u64;
+
+        let start = std::time::Instant::now();
+        let _released = barrier.check_unblocked_operations_indexed();
+        latency_ns += start.elapsed().as_nanos() as u64;
+
+        let metrics = barrier.get_metrics();
+        candidates_examined += metrics.pending_entries_examined;
+        ops_released += metrics.operations_released;
+
+        // Track index entries
+        candidates_discovered = barrier.get_dependency_index().waiters.len() as u64;
+    }
+
+    (latency_ns, candidates_discovered, candidates_examined, ops_released, candidates_discovered)
+}
+
+/// Phase 7.1.3: Crossover Matrix Benchmark
+fn benchmark_crossover_matrix(c: &mut Criterion) {
+    let mut group = c.benchmark_group("phase_7_1_3_crossover");
+    group.sample_size(10);
+
+    // Expanded matrix for crossover analysis
+    let pending_sizes = vec![32, 64, 128, 256, 512, 1_000, 10_000];
+    let selectivities = vec![0.0, 0.01, 0.10, 0.25, 0.50, 0.75, 1.0];
+    let advance_counts = vec![1, 10];
+
+    let mut results = Vec::new();
+
+    println!("\n=== Phase 7.1.3: Crossover Analysis ===");
+    println!("{:>7} {:>3} {:>5} {:>10} {:>12} {:>12} {:>7}",
+        "Pending", "Adv", "Sel%", "FS (µs)", "IX (µs)", "Speedup", "Winner");
+
+    for pending in &pending_sizes {
+        for advances in &advance_counts {
+            for selectivity in &selectivities {
+                let workload = CrossoverWorkload {
+                    pending_size: *pending,
+                    frontier_advances: *advances,
+                    release_selectivity: *selectivity,
+                };
+
+                let (ops, advs) = generate_workload(&workload, 42);
+
+                // Measure both paths
+                let (fs_latency, fs_examined, fs_released) = measure_full_scan(&workload, &ops, &advs);
+                let (ix_latency, ix_discovered, ix_examined, ix_released, ix_entries) =
+                    measure_indexed(&workload, &ops, &advs);
+
+                let speedup = if ix_latency > 0 {
+                    fs_latency as f64 / ix_latency as f64
+                } else {
+                    0.0
+                };
+
+                let winner = if ix_latency < fs_latency { 'I' } else { 'F' };
+
+                let fs_us = fs_latency as f64 / 1000.0;
+                let ix_us = ix_latency as f64 / 1000.0;
+
+                println!("{:>7} {:>3} {:>5.0} {:>10.1} {:>12.1} {:>12.2}x {}",
+                    pending, advances, selectivity * 100.0, fs_us, ix_us, speedup,
+                    if winner == 'I' { "INDEXED" } else { "FULL_SCAN" });
+
+                let metrics = CrossoverMetrics {
+                    pending: *pending,
+                    advances: *advances,
+                    selectivity: *selectivity,
+                    fs_latency_ns: fs_latency,
+                    fs_entries_examined: fs_examined,
+                    fs_ops_released: fs_released,
+                    ix_latency_ns: ix_latency,
+                    ix_candidates_discovered: ix_discovered,
+                    ix_candidates_examined: ix_examined,
+                    ix_ops_released: ix_released,
+                    ix_index_entries: ix_entries,
+                    speedup,
+                    winner,
+                };
+
+                results.push(metrics);
+
+                // Criterion benchmarks for regression gates
+                let bench_name = format!("pending_{}_adv_{}_sel_{:.0}pct",
+                    pending, advances, selectivity * 100.0);
+
+                group.bench_with_input(
+                    BenchmarkId::new("full_scan", &bench_name),
+                    &workload,
+                    |b, w| {
+                        let (ops, advs) = generate_workload(w, 42);
+                        b.iter(|| measure_full_scan(black_box(w), black_box(&ops), black_box(&advs)));
+                    },
+                );
+
+                group.bench_with_input(
+                    BenchmarkId::new("indexed", &bench_name),
+                    &workload,
+                    |b, w| {
+                        let (ops, advs) = generate_workload(w, 42);
+                        b.iter(|| measure_indexed(black_box(w), black_box(&ops), black_box(&advs)));
+                    },
+                );
+            }
+        }
+    }
+
+    group.finish();
+
+    // Write results to CSV for analysis
+    if let Ok(mut file) = File::create("target/phase_7_1_3_crossover.csv") {
+        let _ = writeln!(file,
+            "pending,advances,selectivity_pct,fs_latency_ns,fs_entries_examined,fs_ops_released,\
+             ix_latency_ns,ix_candidates_discovered,ix_candidates_examined,ix_ops_released,\
+             ix_index_entries,speedup,winner,winner_name");
+        for result in &results {
+            let _ = writeln!(file, "{}", result.to_csv());
+        }
+    }
+
+    println!("\nCrossover analysis written to target/phase_7_1_3_crossover.csv");
+}
+
+criterion_group!(benches, benchmark_crossover_matrix);
+criterion_main!(benches);