@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,589 +0,0 @@
-/// Gate 13: Benchmark Baseline (Corrected - Measurement Integrity Phase)
-///
-/// Establish FeltDB's performance envelope with valid, self-validating benchmarks.
-/// This version fixes the invalid 10-node measurement and adds comprehensive
-/// scaling curves and transaction-level benchmarks.
-///
-/// Key changes from initial version:
-/// 1. Vector clock benchmarks now actually measure comparison (not .len())
-/// 2. Scaling curves: 1, 2, 4, 8, 16, 32, 64, 128 nodes
-/// 3. Benchmark self-validation: assertions proving measured work occurred
-/// 4. Separate primitives from transaction benchmarks
-/// 5. 2D matrix: causal barrier vs buffer size × node count
-/// 6. Black box protection on all critical results
-use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
-use feltdb::{
-    CausalDependencyBarrier, ConsistencyContractEnforcer, CrashAtomicExecutor, VectorClock,
-};
-
-/// Helper: Create a vector clock with N nodes
-fn make_vector_clock(node_count: usize) -> VectorClock {
-    let mut clock = VectorClock::new();
-    for i in 0..node_count {
-        clock.clocks.insert(format!("node{}", i), i as u64);
-    }
-    clock
-}
-
-/// Helper: Verify vector clock has expected node count
-fn validate_vector_clock(clock: &VectorClock, expected_nodes: usize) {
-    assert_eq!(
-        clock.clocks.len(),
-        expected_nodes,
-        "Vector clock must have exactly {} nodes",
-        expected_nodes
-    );
-}
-
-/// Vector clock scaling benchmarks (CORRECTED)
-/// Tests actual comparison operations, not just .len()
-fn benchmark_vector_clock_scaling(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_vector_clock_scaling");
-    group.sample_size(100);
-
-    for node_count in [1, 2, 4, 8, 16, 32, 64, 128].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_function(format!("vector_clock_compare_{}_nodes", node_count), |b| {
-            let clock1 = make_vector_clock(*node_count);
-            let mut clock2 = make_vector_clock(*node_count);
-
-            // Validate: clock actually contains expected nodes
-            validate_vector_clock(&clock1, *node_count);
-
-            // Make clock2 slightly different to force actual comparison
-            if let Some(first_node) = clock2.clocks.keys().next().cloned() {
-                if let Some(val) = clock2.clocks.get_mut(&first_node) {
-                    *val += 1;
-                }
-            }
-            validate_vector_clock(&clock2, *node_count);
-
-            b.iter(|| {
-                // Actually perform comparison, not just .len()
-                let result = black_box(&clock1).happens_before(black_box(&clock2));
-                black_box(result)
-            });
-        });
-
-        group.throughput(Throughput::Elements(1));
-        group.bench_function(
-            format!("vector_clock_increment_{}_nodes", node_count),
-            |b| {
-                let mut clock = make_vector_clock(*node_count);
-                validate_vector_clock(&clock, *node_count);
-
-                b.iter(|| {
-                    clock.increment(&"node0");
-                    black_box(clock.get("node0"))
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-/// Vector clock single increment (simplified baseline)
-fn benchmark_vector_clock_increment(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_vector_clock_increment");
-    group.sample_size(100);
-
-    group.throughput(Throughput::Elements(1));
-    group.bench_function("increment_single_node", |b| {
-        let mut clock = VectorClock::new();
-        b.iter(|| {
-            clock.increment(black_box("node1"));
-        });
-    });
-
-    group.finish();
-}
-
-/// Exactly-once cost (deduplication) with scaling
-fn benchmark_exactly_once_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_exactly_once");
-    group.sample_size(100);
-
-    for size in [100, 1000, 10000].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_function(format!("dedup_lookup_{}_ops", size), |b| {
-            let mut executor = CrashAtomicExecutor::new();
-
-            // Pre-populate with N operations
-            for i in 0..*size {
-                let _ = executor.apply_with_crash(&format!("op_{}", i), "rec1", i as i32);
-            }
-
-            b.iter(|| {
-                let result = executor.apply_with_crash("op_duplicate", "rec1", 0);
-                black_box(result)
-            });
-        });
-    }
-
-    group.finish();
-}
-
-/// Causal consistency cost with scaling
-fn benchmark_causal_consistency_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_causal_consistency");
-    group.sample_size(100);
-
-    for node_count in [2, 4, 8, 16, 32].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_function(
-            format!("causal_barrier_receive_{}_nodes", node_count),
-            |b| {
-                let op_required = make_vector_clock(*node_count);
-
-                // Validate: dependencies actually exist
-                validate_vector_clock(&op_required, *node_count);
-
-                b.iter(|| {
-                    let mut barrier = CausalDependencyBarrier::new();
-                    let result = barrier.receive_operation(
-                        format!("op_{}", black_box(1)),
-                        black_box(op_required.clone()),
-                    );
-                    black_box(result)
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-/// Causal barrier with varying buffer sizes (2D matrix)
-fn benchmark_causal_barrier_buffer_scaling(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_causal_buffer_scaling");
-    group.sample_size(50);
-
-    for buffer_size in [0, 10, 100, 1000].iter() {
-        for node_count in [2, 4, 8].iter() {
-            group.throughput(Throughput::Elements(1));
-            group.bench_function(
-                format!("causal_barrier_nodes{}_buffer{}", node_count, buffer_size),
-                |b| {
-                    let required = make_vector_clock(*node_count);
-                    validate_vector_clock(&required, *node_count);
-
-                    b.iter(|| {
-                        let mut barrier = CausalDependencyBarrier::new();
-
-                        // Pre-fill buffer with operations
-                        for i in 0..*buffer_size {
-                            let vc = make_vector_clock(*node_count);
-                            let _ = barrier.receive_operation(format!("op_{}", i), vc);
-                        }
-
-                        let result = barrier
-                            .receive_operation(format!("op_test"), black_box(required.clone()));
-                        black_box(result)
-                    });
-                },
-            );
-        }
-    }
-
-    group.finish();
-}
-
-/// Consistency contract cost
-fn benchmark_consistency_contract_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_consistency_contracts");
-    group.sample_size(100);
-
-    for op_count in [1, 3, 10, 100].iter() {
-        group.throughput(Throughput::Elements(*op_count as u64));
-        group.bench_function(format!("contract_verify_{}_ops", op_count), |b| {
-            let enforcer = ConsistencyContractEnforcer::new();
-            let ops: Vec<i32> = (1..=*op_count).map(|i| i as i32).collect();
-
-            b.iter(|| {
-                let result = enforcer.verify_commutative("Increment", black_box(&ops));
-                black_box(result)
-            });
-        });
-    }
-
-    group.finish();
-}
-
-/// State hashing cost with scaling
-fn benchmark_state_hash_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_state_hash");
-    group.sample_size(100);
-
-    for record_count in [100, 1000, 10000, 100000].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_function(format!("state_hash_{}_records", record_count), |b| {
-            b.iter(|| {
-                let mut hasher = std::collections::hash_map::DefaultHasher::new();
-                use std::hash::{Hash, Hasher};
-
-                for i in 0..*record_count {
-                    format!("record_{}_state", i).hash(&mut hasher);
-                }
-                let hash = hasher.finish();
-                black_box(hash)
-            });
-        });
-    }
-
-    group.finish();
-}
-
-/// Cost of correctness layers (layered architecture cost)
-fn benchmark_cost_of_correctness(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_cost_of_correctness");
-    group.sample_size(50);
-
-    // Layer 1: Base operation
-    group.throughput(Throughput::Elements(1));
-    group.bench_function("layer1_base_operation", |b| {
-        b.iter(|| {
-            let value = black_box(42);
-            let op_type = black_box("Increment");
-            black_box((value, op_type))
-        });
-    });
-
-    // Layer 2: + Vector clock tracking
-    group.throughput(Throughput::Elements(1));
-    group.bench_function("layer2_plus_vector_clock", |b| {
-        let mut clock = VectorClock::new();
-        b.iter(|| {
-            clock.increment("node1");
-            black_box(clock.get("node1"))
-        });
-    });
-
-    // Layer 3: + Deduplication check
-    group.throughput(Throughput::Elements(1));
-    group.bench_function("layer3_plus_dedup_check", |b| {
-        b.iter(|| {
-            let mut dedup = std::collections::HashSet::new();
-            let op_id = "op_1";
-            if !dedup.contains(op_id) {
-                dedup.insert(op_id.to_string());
-            }
-            black_box(dedup.contains(op_id))
-        });
-    });
-
-    // Layer 4: + Causal barrier lookup
-    group.throughput(Throughput::Elements(1));
-    group.bench_function("layer4_plus_causal_barrier", |b| {
-        let mut barrier = CausalDependencyBarrier::new();
-        let required = VectorClock::new();
-        b.iter(|| {
-            let result = barrier.receive_operation("op".to_string(), black_box(required.clone()));
-            black_box(result)
-        });
-    });
-
-    // Layer 5: + Consistency contract check
-    group.throughput(Throughput::Elements(1));
-    group.bench_function("layer5_plus_contract_check", |b| {
-        let contract = ConsistencyContractEnforcer::new();
-        b.iter(|| {
-            let result = contract.verify_commutative("Increment", black_box(&[1]));
-            black_box(result)
-        });
-    });
-
-    group.finish();
-}
-
-/// Phase 7.0.1: Frontier check benchmarks (readiness theorem proof)
-fn benchmark_frontier_check_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_frontier_check");
-    group.sample_size(100);
-
-    for node_count in [1, 2, 4, 8, 16, 32].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_function(format!("frontier_check_{}_nodes", node_count), |b| {
-            let mut barrier = CausalDependencyBarrier::new();
-
-            // Advance frontier to satisfy the check
-            let mut frontier = make_vector_clock(*node_count);
-            barrier.advance_frontier(&frontier);
-
-            // Create requirement that frontier already satisfies
-            let required = frontier.clone();
-            validate_vector_clock(&required, *node_count);
-
-            b.iter(|| {
-                let result = barrier.is_ready_frontier(black_box(&required));
-                black_box(result)
-            });
-        });
-    }
-
-    group.finish();
-}
-
-/// Phase 7.0.1: Frontier update (advancement) benchmarks
-fn benchmark_frontier_update_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_frontier_update");
-    group.sample_size(100);
-
-    for node_count in [1, 2, 4, 8, 16, 32].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_function(format!("frontier_update_{}_nodes", node_count), |b| {
-            let mut barrier = CausalDependencyBarrier::new();
-            let new_frontier = make_vector_clock(*node_count);
-            validate_vector_clock(&new_frontier, *node_count);
-
-            b.iter(|| {
-                barrier.advance_frontier(black_box(&new_frontier));
-            });
-        });
-    }
-
-    group.finish();
-}
-
-/// Phase 7.0.1: Readiness with frontier satisfied (fast path)
-/// Hypothesis: If frontier is sufficient, latency should be independent of buffer size
-fn benchmark_readiness_frontier_satisfied(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_readiness_frontier_satisfied");
-    group.sample_size(50);
-
-    for buffer_size in [0, 10, 100].iter() {
-        for node_count in [2, 4, 8].iter() {
-            group.throughput(Throughput::Elements(1));
-            group.bench_function(
-                format!(
-                    "frontier_satisfied_nodes{}_buffer{}",
-                    node_count, buffer_size
-                ),
-                |b| {
-                    let required = make_vector_clock(*node_count);
-                    validate_vector_clock(&required, *node_count);
-
-                    b.iter(|| {
-                        let mut barrier = CausalDependencyBarrier::new();
-
-                        // Pre-advance frontier to satisfy the requirement
-                        barrier.advance_frontier(&required);
-
-                        // Pre-fill buffer with unrelated operations
-                        for i in 0..*buffer_size {
-                            let mut unrelated = VectorClock::new();
-                            unrelated.increment(&format!("other_node_{}", i));
-                            let _ =
-                                barrier.receive_operation(format!("op_buffer_{}", i), unrelated);
-                        }
-
-                        // Now test readiness check on satisfied requirement
-                        let result = barrier
-                            .receive_operation("op_test".to_string(), black_box(required.clone()));
-                        black_box(result)
-                    });
-                },
-            );
-        }
-    }
-
-    group.finish();
-}
-
-fn benchmark_readiness_frontier_satisfied_corrected(c: &mut Criterion) {
-    // Phase 7.0.2: Corrected benchmark with setup OUTSIDE b.iter()
-    // This isolates the actual readiness check cost from buffer-filling overhead
-    let mut group = c.benchmark_group("gate13_readiness_frontier_satisfied_corrected");
-    group.sample_size(50);
-
-    for buffer_size in [0, 10, 100].iter() {
-        for node_count in [2, 4, 8].iter() {
-            group.throughput(Throughput::Elements(1));
-            group.bench_function(
-                format!(
-                    "frontier_satisfied_corrected_nodes{}_buffer{}",
-                    node_count, buffer_size
-                ),
-                |b| {
-                    let required = make_vector_clock(*node_count);
-                    validate_vector_clock(&required, *node_count);
-
-                    // Setup OUTSIDE b.iter() - only timing the actual readiness check
-                    b.iter_batched(
-                        || {
-                            let mut barrier = CausalDependencyBarrier::new();
-                            barrier.advance_frontier(&required);
-
-                            // Pre-fill buffer with unrelated operations
-                            for i in 0..*buffer_size {
-                                let mut unrelated = VectorClock::new();
-                                unrelated.increment(&format!("other_node_{}", i));
-                                let _ = barrier
-                                    .receive_operation(format!("op_buffer_{}", i), unrelated);
-                            }
-
-                            barrier
-                        },
-                        |mut barrier| {
-                            // ONLY THIS IS TIMED: the actual readiness check
-                            let result = barrier.receive_operation(
-                                "op_test".to_string(),
-                                black_box(required.clone()),
-                            );
-                            black_box(result)
-                        },
-                        criterion::BatchSize::SmallInput,
-                    );
-                },
-            );
-        }
-    }
-
-    group.finish();
-}
-
-/// Phase 7.0.1: Readiness with frontier NOT satisfied (slow path)
-/// Hypothesis: When frontier doesn't satisfy, buffer may need to be scanned
-fn benchmark_readiness_frontier_missing(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_readiness_frontier_missing");
-    group.sample_size(50);
-
-    for buffer_size in [0, 10, 100].iter() {
-        for node_count in [2, 4, 8].iter() {
-            group.throughput(Throughput::Elements(1));
-            group.bench_function(
-                format!("frontier_missing_nodes{}_buffer{}", node_count, buffer_size),
-                |b| {
-                    let mut required = make_vector_clock(*node_count);
-                    // Increment to make requirement higher than what we'll provide
-                    for (_, val) in required.clocks.iter_mut() {
-                        *val += 10;
-                    }
-                    validate_vector_clock(&required, *node_count);
-
-                    b.iter(|| {
-                        let mut barrier = CausalDependencyBarrier::new();
-
-                        // Pre-fill buffer with operations that don't satisfy requirement
-                        for i in 0..*buffer_size {
-                            let mut partial = VectorClock::new();
-                            for j in 0..*node_count {
-                                partial.increment(&format!("node{}", j));
-                            }
-                            let _ = barrier.receive_operation(format!("op_buffer_{}", i), partial);
-                        }
-
-                        // Test readiness check on unsatisfied requirement
-                        let result = barrier
-                            .receive_operation("op_test".to_string(), black_box(required.clone()));
-                        black_box(result)
-                    });
-                },
-            );
-        }
-    }
-
-    group.finish();
-}
-
-/// Phase 7.0.1: Frontier advancement and operation release
-/// Measure what happens when frontier advances and releases pending operations
-fn benchmark_frontier_advancement_release(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_frontier_advancement");
-    group.sample_size(50);
-
-    for pending_count in [10, 100].iter() {
-        group.throughput(Throughput::Elements(*pending_count as u64));
-        group.bench_function(
-            format!("frontier_advancement_release_{}_pending", pending_count),
-            |b| {
-                let mut required = VectorClock::new();
-                required.increment("node_a");
-                required.increment("node_a"); // {node_a: 2}
-                validate_vector_clock(&required, 1);
-
-                b.iter(|| {
-                    let mut barrier = CausalDependencyBarrier::new();
-
-                    // Pre-buffer N operations waiting for {node_a: 2}
-                    for i in 0..*pending_count {
-                        let _ = barrier.receive_operation(format!("op_{}", i), required.clone());
-                    }
-
-                    // Advance frontier to {node_a: 2}, which releases all pending
-                    let mut satisfying = VectorClock::new();
-                    satisfying.increment("node_a");
-                    satisfying.increment("node_a");
-
-                    barrier.advance_frontier(black_box(&satisfying));
-                    black_box(barrier.get_pending_operations())
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-/// Phase 7.0.1: Pathological workload for profiling
-/// This is the scenario we're trying to optimize:
-/// - Multiple nodes (high vector clock cost)
-/// - Large pending buffer (exposes buffer scanning overhead)
-/// - Dependencies already satisfied (should be fast path)
-fn benchmark_causal_pathological_workload(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_causal_pathological");
-    group.sample_size(20);
-
-    group.throughput(Throughput::Elements(1));
-    group.bench_function("pathological_8nodes_10k_pending_satisfied", |b| {
-        let node_count = 8;
-        let pending_count = 10_000;
-
-        // Create a satisfied requirement (all dependencies met)
-        let required = make_vector_clock(node_count);
-        validate_vector_clock(&required, node_count);
-
-        b.iter(|| {
-            let mut barrier = CausalDependencyBarrier::new();
-
-            // Advance frontier to satisfy the requirement
-            barrier.advance_frontier(&required);
-
-            // Pre-buffer 10,000 unrelated operations (don't satisfy requirement)
-            for i in 0..pending_count {
-                let mut unrelated = VectorClock::new();
-                unrelated.increment(&format!("other_node_{}", i % 16));
-                let _ = barrier.receive_operation(format!("pending_{}", i), unrelated);
-            }
-
-            // Now test: incoming operation with already-satisfied requirement
-            // This should be fast if frontier check is sufficient
-            let result =
-                barrier.receive_operation("test_op".to_string(), black_box(required.clone()));
-            black_box(result)
-        });
-    });
-
-    group.finish();
-}
-
-criterion_group!(
-    benches,
-    benchmark_vector_clock_scaling,
-    benchmark_vector_clock_increment,
-    benchmark_exactly_once_cost,
-    benchmark_causal_consistency_cost,
-    benchmark_causal_barrier_buffer_scaling,
-    benchmark_frontier_check_cost,
-    benchmark_frontier_update_cost,
-    benchmark_readiness_frontier_satisfied,
-    benchmark_readiness_frontier_satisfied_corrected,
-    benchmark_readiness_frontier_missing,
-    benchmark_frontier_advancement_release,
-    benchmark_causal_pathological_workload,
-    benchmark_consistency_contract_cost,
-    benchmark_state_hash_cost,
-    benchmark_cost_of_correctness,
-);
-
-criterion_main!(benches);