@feltdb/core 0.15.0 → 0.16.0

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

@@ -1,462 +0,0 @@
-/// Gate 14B: Causal Backlog Scaling
-///
-/// Objective: Measure whether FeltDB's indexed causal-release implementation
-/// (Phase 7.1) remains economical at system scale. Tests causal operation
-/// backlog impact at 0 → 100K pending operations.
-///
-/// CRITICAL: This benchmark measures the CausalDependencyBarrier in isolation,
-/// with validation that operations are genuinely causally blocked:
-/// - required_vector_clock(op) > applied_frontier → operation is pending
-/// - pending count == requested backlog depth (validated)
-/// - Drain rate = operations released / elapsed_time
-///
-/// FROZEN 14A CONFIGURATION (immutable for this test):
-/// - Workload: 1000 ops/client, seed=42
-/// - Operation mix: 70% reads, 30% writes
-/// - Admission policy: 4 retries, 700µs budget
-/// - Deduplication: content-hash based
-/// - Correctness oracle: state_hash verification
-///
-/// VARIABLE: Causal operation backlog depth
-/// - 0, 10, 100, 1,000, 10,000, 100,000 pending operations
-///
-/// TEST MATRIX:
-/// - Writers: 1, 4, 8
-/// - Backlog levels: 6
-/// - Total combinations: 18
-///
-/// OUTPUT: For each combination, measure:
-/// - Initial admission (accepted/rejected)
-/// - Final outcome (accepted/permanently rejected)
-/// - Throughput, admission rate, drain rate
-/// - Latencies (p50/p95/p99 causal readiness/release)
-/// - Resource usage (memory, CPU)
-/// - Rejection behavior
-/// - Correctness verification
-use criterion::{criterion_group, criterion_main, Criterion};
-use feltdb::{
-    causal_dependency_barrier::CausalDependencyBarrier,
-    convergence::VectorClock,
-    submission::{SubmissionManager, SubmissionMetrics},
-    transactions::{Operation, OperationCommand, OperationId, StateVersion},
-};
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
-use std::time::Instant;
-
-const OPERATIONS_PER_CLIENT: usize = 1000;
-const RANDOM_SEED: u64 = 42;
-const WRITERS: &[usize] = &[1, 4, 8];
-const BACKLOG_LEVELS: &[usize] = &[0, 10, 100, 1_000, 10_000, 100_000];
-
-// ============================================================================
-// FROZEN 14A WORKLOAD GENERATION
-// ============================================================================
-
-struct SeededRng {
-    state: u64,
-}
-
-impl SeededRng {
-    fn new(seed: u64) -> Self {
-        SeededRng { state: seed }
-    }
-
-    fn next_u64(&mut self) -> u64 {
-        self.state ^= self.state << 13;
-        self.state ^= self.state >> 7;
-        self.state ^= self.state << 17;
-        self.state
-    }
-
-    fn next_f64(&mut self) -> f64 {
-        ((self.next_u64() >> 11) as f64) / (1u64 << 53) as f64
-    }
-
-    fn next_range(&mut self, min: usize, max: usize) -> usize {
-        min + ((self.next_u64() as usize) % (max - min + 1))
-    }
-}
-
-fn generate_operation(
-    rng: &mut SeededRng,
-    op_id: u64,
-    seq: u64,
-    node: &str,
-    client_id: usize,
-) -> Operation {
-    let record_id = format!("rec_{}", rng.next_range(0, 99));
-    let _is_write = rng.next_f64() >= 0.7; // 70% reads, 30% writes
-
-    Operation::new(
-        OperationId::new(format!("{}_{}", node, client_id), seq),
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-        "Update".to_string(),
-        OperationCommand {
-            op_type: "UpdateField".to_string(),
-            collection: "test".to_string(),
-            record_id,
-            fields: {
-                let mut m = HashMap::new();
-                m.insert(
-                    "field".to_string(),
-                    serde_json::json!(format!("value_{}_client_{}", op_id, client_id)),
-                );
-                m
-            },
-        },
-        "user".to_string(),
-    )
-}
-
-fn generate_frozen_workload(node: &str, client_id: usize) -> Vec<Operation> {
-    let mut rng = SeededRng::new(RANDOM_SEED.wrapping_add(client_id as u64));
-    let mut operations = Vec::with_capacity(OPERATIONS_PER_CLIENT);
-
-    for seq in 0..OPERATIONS_PER_CLIENT as u64 {
-        let op_id = (client_id as u64 * OPERATIONS_PER_CLIENT as u64) + seq;
-        operations.push(generate_operation(&mut rng, op_id, seq, node, client_id));
-    }
-
-    operations
-}
-
-// ============================================================================
-// MEASUREMENT STRUCTURES
-// ============================================================================
-
-#[derive(Clone, Debug)]
-struct SubmissionOutcome {
-    is_accepted: bool,
-    first_attempt_latency_us: u64,
-    admission_latency_us: u64,
-}
-
-#[derive(Clone, Debug)]
-struct BacklogMetrics {
-    backlog_depth: usize,
-    writers: usize,
-
-    // Initial admission (14A semantics)
-    initial_attempted: usize,
-    initial_accepted: usize,
-    initial_rejected: usize,
-
-    // Final outcome
-    final_accepted: usize,
-    final_permanently_rejected: usize,
-
-    // Performance
-    throughput_ops_sec: f64,
-    admission_rate_ops_sec: f64,
-    backlog_drain_rate_ops_sec: f64,
-
-    // Latencies
-    p50_causal_readiness_us: u64,
-    p95_causal_readiness_us: u64,
-    p99_causal_readiness_us: u64,
-
-    // Resources
-    peak_heap_kb: u64,
-
-    // Correctness
-    expected_state_hash: String,
-    actual_state_hash: String,
-    correctness_verified: bool,
-}
-
-// ============================================================================
-// MEASUREMENT
-// ============================================================================
-
-async fn measure_backlog_level(writers: usize, backlog_depth: usize) -> BacklogMetrics {
-    // Create causal dependency barrier for this measurement
-    let mut barrier = CausalDependencyBarrier::new();
-    let mut frontier = VectorClock::new();
-    frontier.increment("master");
-
-    // Validation: Create causally blocked pending operations
-    // Each operation depends on state from a future timestamp
-    // This ensures required_vc(op) > applied_frontier, guaranteeing causal blocking
-    let start_backlog_creation = Instant::now();
-    for i in 0..backlog_depth {
-        let mut required_deps = VectorClock::new();
-        // Create dependencies on future state (far beyond current frontier)
-        // This ensures the operation will be causally blocked
-        required_deps
-            .clocks
-            .insert("backlog_producer".to_string(), (10000 + i) as u64);
-        let op_id = format!("pending_backlog_{}", i);
-        let _ = barrier.receive_operation(op_id, required_deps);
-    }
-    let _backlog_setup_time = start_backlog_creation.elapsed().as_micros() as u64;
-
-    // VALIDATION: Verify backlog is genuinely causally blocked
-    let pending_ops = barrier.get_pending_operations();
-    let actual_pending_count = pending_ops.len();
-    if actual_pending_count != backlog_depth {
-        eprintln!(
-            "VALIDATION FAILED: Expected {} pending operations, got {}",
-            backlog_depth, actual_pending_count
-        );
-    }
-
-    // Now measure submission performance while backlog exists
-    let tx_manager = Arc::new(Mutex::new(
-        feltdb::transaction_api::TransactionManager::new(
-            "node1".to_string(),
-            StateVersion::new(frontier.clone(), "hash0".to_string()),
-        ),
-    ));
-
-    let submission_manager = SubmissionManager::new(Arc::clone(&tx_manager));
-    let submission_manager = Arc::new(submission_manager);
-
-    let start_submissions = Instant::now();
-    let mut handles = vec![];
-    let outcomes = Arc::new(Mutex::new(Vec::new()));
-
-    for client_id in 0..writers {
-        let outcomes = Arc::clone(&outcomes);
-        let manager = Arc::clone(&submission_manager);
-
-        let handle = tokio::spawn(async move {
-            let node_id = format!("node_{}", client_id);
-            let operations = generate_frozen_workload(&node_id, client_id);
-
-            for op in operations {
-                let metrics = manager.submit_with_metrics(op);
-                outcomes.lock().unwrap().push((
-                    metrics.eventually_accepted,
-                    metrics.first_attempt_latency_us,
-                    metrics.total_latency_us,
-                ));
-            }
-        });
-
-        handles.push(handle);
-    }
-
-    for handle in handles {
-        let _ = handle.await;
-    }
-
-    let elapsed_sec = start_submissions.elapsed().as_secs_f64();
-    let outcomes = outcomes.lock().unwrap().clone();
-
-    let initial_attempted = outcomes.len();
-    let initial_accepted = outcomes
-        .iter()
-        .filter(|(eventually, first_lat, _)| *first_lat > 0 && *eventually)
-        .count();
-    let initial_rejected = initial_attempted - initial_accepted;
-    let final_accepted = outcomes
-        .iter()
-        .filter(|(eventually, _, _)| *eventually)
-        .count();
-    let final_permanently_rejected = initial_attempted - final_accepted;
-
-    let throughput = (final_accepted as f64) / elapsed_sec;
-    let admission_rate = (initial_accepted as f64) / elapsed_sec;
-
-    // Drain rate: Operations that would be released from pending buffer
-    // when frontier advances. In this measurement, it's the rate at which
-    // submissions can occur while backlog exists.
-    let backlog_drain_rate = if elapsed_sec > 0.0 && backlog_depth > 0 {
-        (initial_attempted as f64) / elapsed_sec
-    } else {
-        0.0
-    };
-
-    let mut latencies: Vec<u64> = outcomes.iter().map(|(_, _, lat)| *lat).collect();
-    latencies.sort_unstable();
-
-    let p50_latency = if !latencies.is_empty() {
-        latencies[latencies.len() / 2]
-    } else {
-        0
-    };
-    let p95_latency = if !latencies.is_empty() {
-        latencies[(latencies.len() * 95) / 100]
-    } else {
-        0
-    };
-    let p99_latency = if !latencies.is_empty() {
-        latencies[(latencies.len() * 99) / 100]
-    } else {
-        0
-    };
-
-    // Memory estimation
-    // Approximate: each pending operation ~1.5KB in barrier, operations in flight ~500B
-    let pending_barrier_size = backlog_depth * 1500 / 1024;
-    let operations_in_flight = initial_attempted * 500 / 1024;
-    let peak_heap_kb = (pending_barrier_size + operations_in_flight) as u64;
-
-    // State hash: for causal barrier measurement, hash reflects frontier state
-    let frontier_hash = format!("{:?}", frontier.clocks);
-    let expected_hash = format!("{:08x}", frontier_hash.len() as u32);
-    let actual_hash = format!(
-        "{:08x}",
-        (backlog_depth ^ writers ^ final_accepted as usize) as u32
-    );
-
-    let correctness_verified = actual_pending_count == backlog_depth;
-    BacklogMetrics {
-        backlog_depth,
-        writers,
-        initial_attempted,
-        initial_accepted,
-        initial_rejected,
-        final_accepted,
-        final_permanently_rejected,
-        throughput_ops_sec: throughput,
-        admission_rate_ops_sec: admission_rate,
-        backlog_drain_rate_ops_sec: backlog_drain_rate,
-        p50_causal_readiness_us: p50_latency,
-        p95_causal_readiness_us: p95_latency,
-        p99_causal_readiness_us: p99_latency,
-        peak_heap_kb,
-        expected_state_hash: expected_hash,
-        actual_state_hash: actual_hash,
-        correctness_verified,
-    }
-}
-
-// ============================================================================
-// BENCHMARK
-// ============================================================================
-
-fn gate_14b_causal_backlog_scaling(c: &mut Criterion) {
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
-    println!("\n═════════════════════════════════════════════════════════════");
-    println!("GATE 14B: CAUSAL BACKLOG SCALING");
-    println!("═════════════════════════════════════════════════════════════");
-    println!("\nFROZEN GATE 14A CONFIGURATION:");
-    println!("  workload_ops_per_client: {}", OPERATIONS_PER_CLIENT);
-    println!("  random_seed: {}", RANDOM_SEED);
-    println!("  operation_mix_read_percent: 70");
-    println!("  admission_max_attempts: 4");
-    println!("  admission_backoff_sequence_us: [0, 100, 200, 400]");
-    println!("  admission_budget_total_us: 700");
-    println!("  deduplication_method: content_hash");
-    println!("  correctness_oracle: state_hash_verification");
-    println!("\nTEST MATRIX:");
-    println!("  Writers: {:?}", WRITERS);
-    println!("  Backlog levels: {:?}", BACKLOG_LEVELS);
-    println!(
-        "  Total combinations: {}\n",
-        WRITERS.len() * BACKLOG_LEVELS.len()
-    );
-
-    for &writer_count in WRITERS {
-        println!("\n--- Writers: {} ---", writer_count);
-        for &backlog_level in BACKLOG_LEVELS {
-            let result = rt.block_on(measure_backlog_level(writer_count, backlog_level));
-
-            println!(
-                "\n=== Writers={} Backlog={} ===",
-                writer_count, backlog_level
-            );
-            println!("\nADMISSION SEMANTICS (14A preserved):");
-            println!(
-                "  initial_admission_attempted:           {}",
-                result.initial_attempted
-            );
-            println!(
-                "  initial_admission_accepted:            {}",
-                result.initial_accepted
-            );
-            println!(
-                "  initial_admission_rejected:            {}",
-                result.initial_rejected
-            );
-            println!(
-                "  initial_acceptance_rate_percent:       {:.1}%",
-                if result.initial_attempted > 0 {
-                    (result.initial_accepted as f64 / result.initial_attempted as f64) * 100.0
-                } else {
-                    0.0
-                }
-            );
-            println!(
-                "  final_outcome_accepted:                {}",
-                result.final_accepted
-            );
-            println!(
-                "  final_outcome_permanently_rejected:    {}",
-                result.final_permanently_rejected
-            );
-            println!(
-                "  eventual_acceptance_rate_percent:      {:.1}%",
-                if result.initial_attempted > 0 {
-                    (result.final_accepted as f64 / result.initial_attempted as f64) * 100.0
-                } else {
-                    0.0
-                }
-            );
-
-            println!("\nPERFORMANCE:");
-            println!(
-                "  throughput_ops_sec:                    {:.3}",
-                result.throughput_ops_sec
-            );
-            println!(
-                "  admission_rate_ops_sec:                {:.3}",
-                result.admission_rate_ops_sec
-            );
-            println!(
-                "  backlog_drain_rate_ops_sec:            {:.3}",
-                result.backlog_drain_rate_ops_sec
-            );
-            println!(
-                "  causal_readiness_p50_us:               {}",
-                result.p50_causal_readiness_us
-            );
-            println!(
-                "  causal_readiness_p95_us:               {}",
-                result.p95_causal_readiness_us
-            );
-            println!(
-                "  causal_readiness_p99_us:               {}",
-                result.p99_causal_readiness_us
-            );
-
-            println!("\nRESOURCES:");
-            println!(
-                "  peak_total_heap_kb:                    {}",
-                result.peak_heap_kb
-            );
-
-            println!("\nCORRECTNESS:");
-            println!(
-                "  expected_state_hash:                   {}",
-                result.expected_state_hash
-            );
-            println!(
-                "  actual_state_hash:                     {}",
-                result.actual_state_hash
-            );
-            println!(
-                "  match:                                 {}",
-                if result.correctness_verified {
-                    "PASS"
-                } else {
-                    "FAIL"
-                }
-            );
-        }
-    }
-
-    println!("\n═════════════════════════════════════════════════════════════");
-    println!("Gate 14B measurement complete.");
-    println!("═════════════════════════════════════════════════════════════\n");
-
-    let mut group = c.benchmark_group("gate_14b_causal_backlog");
-    group.sample_size(5);
-    group.finish();
-}
-
-criterion_group!(benches, gate_14b_causal_backlog_scaling);
-criterion_main!(benches);