@feltdb/core 0.15.0 → 0.16.0

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

@@ -1,421 +0,0 @@
-/// 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, BenchmarkId, Criterion};
-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);