@feltdb/core 0.4.11 → 0.4.13

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

@@ -0,0 +1,589 @@
+/// 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);