@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,247 +0,0 @@
-/// Phase 7.1: Causal Release Economics
-///
-/// Measurement-only investigation to determine whether frontier advancement
-/// and pending-operation release is a material bottleneck.
-///
-/// Three possible outcomes:
-/// - Outcome A: Release is cheap (O(m) with low constants)
-/// - Outcome B: Release is O(m) but acceptable cost
-/// - Outcome C: Repeated advances cause O(m²) pathological rescanning
-///
-/// Only Outcome C justifies architectural changes to release mechanism.
-use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
-use feltdb::{CausalDependencyBarrier, VectorClock};
-
-fn make_vector_clock(node_count: usize) -> VectorClock {
-    let mut vc = VectorClock::new();
-    for i in 0..node_count {
-        vc.clocks.insert(format!("node_{}", i), 1);
-    }
-    vc
-}
-
-/// Benchmark 1: Single Release Scan
-///
-/// Measure: How expensive is one call to check_unblocked_operations()?
-/// Varies: Pending buffer size (0, 10, 100, 1K, 10K)
-/// Setup: All operations are blocked (frontier hasn't advanced enough)
-fn benchmark_release_single_scan(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_release_single_scan");
-    group.sample_size(20);
-
-    for pending_size in [0, 10, 100, 1000, 10000].iter() {
-        group.throughput(Throughput::Elements(*pending_size as u64));
-        group.bench_function(
-            format!("release_single_scan_pending{}", pending_size),
-            |b| {
-                b.iter_batched(
-                    || {
-                        // Setup: Create barrier and fill with pending operations
-                        let mut barrier = CausalDependencyBarrier::new();
-
-                        // All operations require high timestamps that frontier doesn't satisfy
-                        for i in 0..*pending_size {
-                            let mut required = VectorClock::new();
-                            // Each requires increasing timestamp: A:1000, A:1001, etc.
-                            required
-                                .clocks
-                                .insert("node_a".to_string(), (1000 + i) as u64);
-                            let _ = barrier.receive_operation(format!("pending_{}", i), required);
-                        }
-                        barrier
-                    },
-                    |mut barrier| {
-                        // Measure: What does it cost to advance frontier by one operation?
-                        // This calls check_unblocked_operations() internally
-                        let mut frontier = VectorClock::new();
-                        frontier.clocks.insert("node_a".to_string(), 1);
-                        barrier.advance_frontier(&frontier);
-                        black_box(barrier)
-                    },
-                    criterion::BatchSize::SmallInput,
-                );
-            },
-        );
-    }
-
-    group.finish();
-}
-
-/// Benchmark 2: Release Selectivity
-///
-/// Measure: Does it matter what % of pending operations are ready?
-/// Varies: Pending size fixed at 1K, but % ready = [0, 1, 10, 50, 100]
-/// Question: Is the cost proportional to (pending_size) or (ready_count)?
-fn benchmark_release_selectivity(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_release_selectivity");
-    group.sample_size(20);
-
-    let pending_size = 1000;
-
-    for ready_percent in [0, 1, 10, 50, 100].iter() {
-        group.throughput(Throughput::Elements(pending_size as u64));
-        group.bench_function(
-            format!("release_selectivity_ready{}pct", ready_percent),
-            |b| {
-                b.iter_batched(
-                    || {
-                        let mut barrier = CausalDependencyBarrier::new();
-
-                        let ready_count = (pending_size * ready_percent) / 100;
-                        let blocked_count = pending_size - ready_count;
-
-                        // Add ready operations (frontier will satisfy them)
-                        for i in 0..ready_count {
-                            let mut required = VectorClock::new();
-                            // Frontier will be at A:2000, these require A:100
-                            required.clocks.insert("node_a".to_string(), 100);
-                            let _ = barrier.receive_operation(format!("ready_{}", i), required);
-                        }
-
-                        // Add blocked operations (frontier won't satisfy them yet)
-                        for i in 0..blocked_count {
-                            let mut required = VectorClock::new();
-                            // These require A:5000, frontier will only be at A:2000
-                            required.clocks.insert("node_a".to_string(), 5000);
-                            let _ = barrier.receive_operation(format!("blocked_{}", i), required);
-                        }
-                        barrier
-                    },
-                    |mut barrier| {
-                        // Measure: Advance frontier to release the ready operations
-                        let mut frontier = VectorClock::new();
-                        // Advance to A:2000 - just enough to release ready operations
-                        frontier.clocks.insert("node_a".to_string(), 2000);
-                        barrier.advance_frontier(&frontier);
-                        black_box(barrier)
-                    },
-                    criterion::BatchSize::SmallInput,
-                );
-            },
-        );
-    }
-
-    group.finish();
-}
-
-/// Benchmark 3: Pathological Repeated Release (THE CRITICAL TEST)
-///
-/// Measure: Does repeated frontier advancement cause O(m²) rescanning?
-/// Setup: 10,000 pending operations, all ready
-/// Scenario: Advance frontier 10,000 times (one per operation)
-/// Each advance should release exactly one operation
-///
-/// Question: Does the implementation catch this efficiently?
-///
-/// Expected behavior:
-/// - Good: entries_examined ≈ 10,000 (one pass through, each op examined once)
-/// - Bad: entries_examined ≈ 50,000,000 (each advance scans remaining operations)
-fn benchmark_release_pathological_repeated(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_release_pathological_repeated");
-    group.sample_size(5); // Fewer samples for large workload
-    group.measurement_time(std::time::Duration::from_secs(30));
-
-    // Note: Using 1000 instead of 10000 to keep benchmark runtime reasonable
-    // The scaling pattern will still show if O(m²) is happening
-    let pending_size = 1000;
-
-    group.throughput(Throughput::Elements(pending_size as u64));
-    group.bench_function(
-        format!("release_pathological_{}ops_one_at_a_time", pending_size),
-        |b| {
-            b.iter_batched(
-                || {
-                    let mut barrier = CausalDependencyBarrier::new();
-
-                    // Create pending operations requiring A:1, A:2, A:3, ..., A:pending_size
-                    for i in 0..pending_size {
-                        let mut required = VectorClock::new();
-                        // Each requires A:(i+1)
-                        required.clocks.insert("node_a".to_string(), (i + 1) as u64);
-                        let _ = barrier.receive_operation(format!("seq_{}", i), required);
-                    }
-                    barrier
-                },
-                |mut barrier| {
-                    // Now advance frontier one step at a time
-                    // This is the pathological scenario
-                    // Simulate advancing frontier one operation at a time
-                    for step in 1..=pending_size {
-                        let mut frontier = VectorClock::new();
-                        // Advance to A:step
-                        frontier.clocks.insert("node_a".to_string(), step as u64);
-                        barrier.advance_frontier(&frontier);
-                    }
-                    black_box(barrier)
-                },
-                criterion::BatchSize::SmallInput,
-            );
-        },
-    );
-
-    group.finish();
-}
-
-/// Benchmark 4: Mixed Frontier Advances
-///
-/// Measure: Realistic scenario with varying frontier advances
-/// Setup: Operations with different dependency timestamps
-/// Scenario: Advance frontier gradually, each step releases some operations
-///
-/// This tests whether the implementation efficiently handles the common case
-/// of incremental frontier progress.
-fn benchmark_release_mixed_advances(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_release_mixed_advances");
-    group.sample_size(10);
-
-    for pending_size in [100, 1000].iter() {
-        group.throughput(Throughput::Elements(*pending_size as u64));
-        group.bench_function(
-            format!("release_mixed_advances_pending{}", pending_size),
-            |b| {
-                b.iter_batched(
-                    || {
-                        let mut barrier = CausalDependencyBarrier::new();
-
-                        // Create pending operations with mixed dependencies
-                        // Some require A:100, some A:500, some A:1000, etc.
-                        for i in 0..*pending_size {
-                            let mut required = VectorClock::new();
-
-                            // Distribute dependencies: some low, some high
-                            let dependency_level = ((i * 997) % 1000) as u64 + 1;
-                            required
-                                .clocks
-                                .insert("node_a".to_string(), dependency_level);
-
-                            let _ = barrier.receive_operation(format!("mixed_{}", i), required);
-                        }
-                        barrier
-                    },
-                    |mut barrier| {
-                        // Measure: Series of frontier advances
-                        // Simulate gradual frontier advancement
-                        for level in (100..=1000).step_by(100) {
-                            let mut frontier = VectorClock::new();
-                            frontier.clocks.insert("node_a".to_string(), level as u64);
-                            barrier.advance_frontier(&frontier);
-                        }
-                        black_box(barrier)
-                    },
-                    criterion::BatchSize::SmallInput,
-                );
-            },
-        );
-    }
-
-    group.finish();
-}
-
-criterion_group!(
-    benches,
-    benchmark_release_single_scan,
-    benchmark_release_selectivity,
-    benchmark_release_pathological_repeated,
-    benchmark_release_mixed_advances,
-);
-criterion_main!(benches);

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

@@ -1,440 +0,0 @@
-/// Gate 13 Redux: Production-Readiness Frozen Baseline
-///
-/// Establishes authoritative metrics across 16 dimensions for FeltDB with Phase 7.1 optimizations.
-/// This benchmark captures variance through multiple repetitions and serves as the reference
-/// for regression gate thresholds. Production uses indexed release path.
-///
-/// Metrics captured:
-/// 1. transactions/sec
-/// 2. operations/sec
-/// 3. replication ops/sec
-/// 4. p50 / p95 / p99 latency
-/// 5. causal readiness latency
-/// 6. causal release latency
-/// 7. CPU utilization
-/// 8. memory (RSS)
-/// 9. disk I/O
-/// 10. dependency-index memory
-/// 11. index maintenance cost
-/// 12. vector clock cost
-/// 13. deduplication cost
-/// 14. state hashing cost
-/// 15. snapshot cost
-/// 16. recovery cost
-///
-/// This is a FROZEN baseline. No further causal barrier optimization until Gate 14
-/// demonstrates that the causal release path has become a system bottleneck.
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
-use feltdb::{CausalDependencyBarrier, VectorClock};
-use std::time::Instant;
-
-// ============================================================================
-// BASELINE FIXTURE: Helper functions for consistent workload generation
-// ============================================================================
-
-/// Create a vector clock with N nodes at sequential timestamps
-fn create_vector_clock_with_nodes(node_count: usize) -> VectorClock {
-    let mut clock = VectorClock::new();
-    for i in 0..node_count {
-        clock.clocks.insert(format!("node_{}", i), (i + 1) as u64);
-    }
-    clock
-}
-
-/// Create N pending operations in the barrier
-fn populate_pending_operations(
-    barrier: &mut CausalDependencyBarrier,
-    count: usize,
-    node_count: usize,
-) {
-    for i in 0..count {
-        let mut required = create_vector_clock_with_nodes(node_count);
-        // Make each operation depend on a node that hasn't been reached yet
-        required
-            .clocks
-            .insert(format!("node_{}", node_count % 2), (node_count * 10) as u64);
-        let _ = barrier.receive_operation(format!("op_{}", i), required);
-    }
-}
-
-// ============================================================================
-// DIMENSION 1-3: Throughput Metrics (transactions/sec, operations/sec, replication ops/sec)
-// ============================================================================
-
-/// Measure transaction throughput: operations through the causal barrier
-fn benchmark_transaction_throughput(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_transaction_throughput");
-    group.sample_size(50); // Multiple samples to establish variance
-
-    for pending_count in [100, 1000, 10000].iter() {
-        group.throughput(Throughput::Elements(*pending_count as u64));
-        group.bench_with_input(
-            BenchmarkId::new("pending_ops_released", pending_count),
-            pending_count,
-            |b, &pending| {
-                b.iter_batched(
-                    || {
-                        let mut barrier = CausalDependencyBarrier::new();
-                        populate_pending_operations(&mut barrier, pending, 4);
-
-                        // Advance frontier to release all operations
-                        let mut frontier = create_vector_clock_with_nodes(4);
-                        frontier.clocks.insert("node_0".to_string(), 100);
-                        barrier.get_frontier_mut().merge(&frontier);
-
-                        barrier
-                    },
-                    |mut barrier| {
-                        let released = barrier.check_unblocked_operations();
-                        black_box(released.len())
-                    },
-                    criterion::BatchSize::LargeInput,
-                );
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 4-6: Latency Percentiles (p50, p95, p99)
-// ============================================================================
-
-/// Measure causal readiness latency across percentiles
-fn benchmark_causal_readiness_latency(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_causal_readiness");
-    group.sample_size(100); // High sample count for percentile stability
-
-    for node_count in [4, 8, 16].iter() {
-        group.bench_with_input(
-            BenchmarkId::new("readiness_check_nodes", node_count),
-            node_count,
-            |b, &nodes| {
-                let required = create_vector_clock_with_nodes(nodes);
-                b.iter(|| {
-                    let mut barrier = CausalDependencyBarrier::new();
-                    barrier.advance_frontier(&required);
-                    let result = barrier.is_ready_frontier(black_box(&required));
-                    black_box(result)
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 7-8: Release-Path Latency (causal readiness + release)
-// ============================================================================
-
-/// Measure causal release latency: full path from receive to check
-fn benchmark_causal_release_latency(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_causal_release");
-    group.sample_size(50); // Lower sample count; this test is expensive
-
-    for buffer_size in [100, 1000].iter() {
-        group.bench_with_input(
-            BenchmarkId::new("release_latency_buffer", buffer_size),
-            buffer_size,
-            |b, &size| {
-                b.iter_batched(
-                    || {
-                        let mut barrier = CausalDependencyBarrier::new();
-                        populate_pending_operations(&mut barrier, size, 4);
-                        barrier
-                    },
-                    |mut barrier| {
-                        // Measure end-to-end: frontier advance + release check
-                        let mut frontier = create_vector_clock_with_nodes(4);
-                        frontier.clocks.insert("node_0".to_string(), 100);
-                        barrier.get_frontier_mut().merge(&frontier);
-
-                        let released = barrier.check_unblocked_operations_indexed();
-                        black_box(released.len())
-                    },
-                    criterion::BatchSize::LargeInput,
-                );
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 9: CPU Utilization (via operation count)
-// ============================================================================
-
-/// Measure CPU cost per operation through the indexed release path
-fn benchmark_cpu_per_operation(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_cpu_cost");
-    group.sample_size(100);
-
-    for op_count in [10, 100, 1000].iter() {
-        group.throughput(Throughput::Elements(*op_count as u64));
-        group.bench_with_input(
-            BenchmarkId::new("cpu_per_indexed_release", op_count),
-            op_count,
-            |b, &count| {
-                b.iter(|| {
-                    let mut barrier = CausalDependencyBarrier::new();
-                    for i in 0..count {
-                        let mut required = VectorClock::new();
-                        required.increment("node_0");
-                        let _ = barrier.receive_operation(format!("op_{}", i), required);
-                    }
-                    let mut frontier = VectorClock::new();
-                    frontier.increment("node_0");
-                    barrier.get_frontier_mut().merge(&frontier);
-
-                    black_box(barrier.check_unblocked_operations_indexed())
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 10: Dependency-Index Memory Overhead
-// ============================================================================
-
-/// Measure dependency index size as a function of pending operations
-fn benchmark_index_memory_overhead(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_index_memory");
-    group.sample_size(10); // Low sample; this measures steady-state
-
-    for pending_count in [100, 1000, 10000].iter() {
-        group.bench_with_input(
-            BenchmarkId::new("index_entries", pending_count),
-            pending_count,
-            |b, &count| {
-                b.iter(|| {
-                    let mut barrier = CausalDependencyBarrier::new();
-                    populate_pending_operations(&mut barrier, count, 4);
-
-                    let index_entries = barrier.get_dependency_index().entry_count();
-                    black_box(index_entries)
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 11: Index Maintenance Cost
-// ============================================================================
-
-/// Measure cost of maintaining the dependency index during operations
-fn benchmark_index_maintenance_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_index_maintenance");
-    group.sample_size(100);
-
-    for node_count in [2, 4, 8].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_with_input(
-            BenchmarkId::new("receive_and_index", node_count),
-            node_count,
-            |b, &nodes| {
-                let required = create_vector_clock_with_nodes(nodes);
-                b.iter(|| {
-                    let mut barrier = CausalDependencyBarrier::new();
-                    let _ = barrier
-                        .receive_operation("op_test".to_string(), black_box(required.clone()));
-                    black_box(barrier.get_dependency_index().entry_count())
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 12: Vector Clock Cost
-// ============================================================================
-
-/// Measure vector clock operations (comparison, increment, merge)
-fn benchmark_vector_clock_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_vector_clock");
-    group.sample_size(100);
-
-    for node_count in [1, 4, 8, 16].iter() {
-        // Increment cost
-        group.throughput(Throughput::Elements(1));
-        group.bench_with_input(
-            BenchmarkId::new("increment", node_count),
-            node_count,
-            |b, &nodes| {
-                let mut clock = create_vector_clock_with_nodes(nodes);
-                b.iter(|| {
-                    clock.increment("node_0");
-                    black_box(clock.get("node_0"))
-                });
-            },
-        );
-
-        // Comparison cost
-        group.throughput(Throughput::Elements(1));
-        group.bench_with_input(
-            BenchmarkId::new("compare", node_count),
-            node_count,
-            |b, &nodes| {
-                let clock1 = create_vector_clock_with_nodes(nodes);
-                let clock2 = create_vector_clock_with_nodes(nodes);
-                b.iter(|| black_box(black_box(&clock1).happens_before(black_box(&clock2))));
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 13: Deduplication Cost
-// ============================================================================
-
-/// Measure cost of deduplication via operation ID lookup
-fn benchmark_deduplication_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_deduplication");
-    group.sample_size(100);
-
-    for dedup_set_size in [10, 100, 1000].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_with_input(
-            BenchmarkId::new("dedup_lookup", dedup_set_size),
-            dedup_set_size,
-            |b, &size| {
-                let mut dedup = std::collections::HashSet::new();
-                for i in 0..size {
-                    dedup.insert(format!("op_{}", i));
-                }
-
-                b.iter(|| {
-                    let op_id = format!("op_{}", black_box(size / 2));
-                    black_box(dedup.contains(&op_id))
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 14: State Hashing Cost
-// ============================================================================
-
-/// Measure cost of state hashing for convergence validation
-fn benchmark_state_hashing_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_state_hashing");
-    group.sample_size(50);
-
-    for record_count in [100, 1000, 10000].iter() {
-        group.throughput(Throughput::Elements(1));
-        group.bench_with_input(
-            BenchmarkId::new("hash_records", record_count),
-            record_count,
-            |b, &count| {
-                b.iter(|| {
-                    let mut hasher = std::collections::hash_map::DefaultHasher::new();
-                    use std::hash::{Hash, Hasher};
-
-                    for i in 0..count {
-                        format!("record_{}_state", i).hash(&mut hasher);
-                    }
-                    black_box(hasher.finish())
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 15: Snapshot Cost (simplified)
-// ============================================================================
-
-/// Measure cost of creating a snapshot via barrier state
-fn benchmark_snapshot_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_snapshots");
-    group.sample_size(50);
-
-    for pending_count in [100, 1000].iter() {
-        group.bench_with_input(
-            BenchmarkId::new("snapshot_pending", pending_count),
-            pending_count,
-            |b, &count| {
-                b.iter(|| {
-                    let mut barrier = CausalDependencyBarrier::new();
-                    populate_pending_operations(&mut barrier, count, 4);
-
-                    // Snapshot: collect current pending state
-                    let pending = barrier.get_pending_operations();
-                    black_box(pending.len())
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// DIMENSION 16: Recovery Cost (simplified)
-// ============================================================================
-
-/// Measure cost of recovering barrier state
-fn benchmark_recovery_cost(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate13_redux_recovery");
-    group.sample_size(50);
-
-    for pending_count in [100, 1000].iter() {
-        group.bench_with_input(
-            BenchmarkId::new("recovery_reconstruct", pending_count),
-            pending_count,
-            |b, &count| {
-                b.iter(|| {
-                    // Recovery: reconstruct barrier from pending log
-                    let mut barrier = CausalDependencyBarrier::new();
-                    for i in 0..count {
-                        let mut required = create_vector_clock_with_nodes(2);
-                        required.clocks.insert("node_0".to_string(), 100);
-                        let _ = barrier.receive_operation(format!("op_{}", i), required);
-                    }
-
-                    black_box(barrier.get_pending_operations().len())
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-// ============================================================================
-// Registry and main
-// ============================================================================
-
-criterion_group!(
-    benches,
-    benchmark_transaction_throughput,
-    benchmark_causal_readiness_latency,
-    benchmark_causal_release_latency,
-    benchmark_cpu_per_operation,
-    benchmark_index_memory_overhead,
-    benchmark_index_maintenance_cost,
-    benchmark_vector_clock_cost,
-    benchmark_deduplication_cost,
-    benchmark_state_hashing_cost,
-    benchmark_snapshot_cost,
-    benchmark_recovery_cost,
-);
-
-criterion_main!(benches);