@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,467 +0,0 @@
-/// Gate 14A Revalidation: Production Admission Contract
-///
-/// Objective: Validate FeltDB behavior under the production admission contract.
-/// Measures whether the production admission contract and retry policy adequately
-/// handle the contention that triggered failures at 8+ writers.
-///
-/// FROZEN WORKLOAD (identical to Gate 14A):
-/// - 1000 operations per client
-/// - 1-8 concurrent writers
-/// - Deterministic replay
-///
-/// KEY METRICS (per concurrency level):
-/// - Accepted operations (count & %)
-/// - Rejected operations (count & %)
-/// - Rejection reasons breakdown (Backpressure vs TransientLockContention vs other)
-/// - Retry attempts needed per operation
-/// - p50, p95, p99 submission latency
-/// - Throughput (accepted ops/sec)
-/// - Actual vs expected rejection rates
-/// - State machine correctness verification
-///
-/// SUCCESS CRITERIA:
-/// ✓ All operations produce explicit outcome (no silent drops)
-/// ✓ Rejection reasons are actionable (allow retry with guidance)
-/// ✓ Duplicate detection works under load
-/// ✓ State machine remains correct even with rejections
-/// ✓ Rejection rate increases predictably with concurrency
-///
-/// EXPECTED OUTCOME:
-/// At 8 writers (previous failure point), the production admission contract should:
-/// 1. Explicitly report rejections (not silent failures)
-/// 2. Allow callers to retry safely
-/// 3. Maintain state correctness
-/// 4. Show measurable rejection rate with clear retry guidance
-use criterion::{criterion_group, criterion_main, Criterion};
-use feltdb::{
-    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 CONCURRENCY_LEVELS: &[usize] = &[1, 2, 4, 6, 7, 8];
-const RANDOM_SEED: u64 = 42;
-
-// ============================================================================
-// WORKLOAD GENERATION (FROZEN)
-// ============================================================================
-
-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(
-        // Use both node and sequence to ensure uniqueness across clients
-        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();
-                // Include client_id in the value to ensure uniqueness
-                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
-}
-
-// ============================================================================
-// OUTCOME TRACKING
-// ============================================================================
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum OutcomeType {
-    Accepted,
-    RejectedBackpressure,
-    RejectedLockContention,
-    RejectedDuplicate,
-    RejectedOther,
-}
-
-#[derive(Clone, Debug)]
-struct SubmissionRecord {
-    outcome_type: OutcomeType,
-    first_attempt_latency_us: u64,
-    admission_latency_us: u64, // Time to final accepted/rejected outcome
-    retry_attempts: usize,
-    eventually_accepted: bool,
-}
-
-#[derive(Clone, Debug)]
-struct ProductionAdmissionResult {
-    total_operations: usize,
-    first_attempt_accepted: usize,
-    first_attempt_rejected: usize,
-    eventually_accepted: usize,
-    permanently_rejected: usize,
-    total_retry_attempts: usize,
-    avg_retries: f64,
-    p50_first_attempt_latency_us: u64,
-    p95_first_attempt_latency_us: u64,
-    p99_first_attempt_latency_us: u64,
-    p50_admission_latency_us: u64,
-    p95_admission_latency_us: u64,
-    p99_admission_latency_us: u64,
-    retry_amplification: f64,
-    contract_verified: bool,
-}
-
-impl ProductionAdmissionResult {
-    fn from_records(records: &[SubmissionRecord], _wall_clock_ms: f64) -> Self {
-        let total = records.len();
-        let first_attempt_accepted = records
-            .iter()
-            .filter(|r| r.outcome_type == OutcomeType::Accepted && r.retry_attempts == 0)
-            .count();
-        let first_attempt_rejected = total - first_attempt_accepted;
-        let eventually_accepted = records.iter().filter(|r| r.eventually_accepted).count();
-        let permanently_rejected = total - eventually_accepted;
-        let total_retry_attempts: usize = records.iter().map(|r| r.retry_attempts).sum();
-
-        let avg_retries = if total > 0 {
-            records.iter().map(|r| r.retry_attempts as f64).sum::<f64>() / total as f64
-        } else {
-            0.0
-        };
-
-        let mut first_attempt_latencies: Vec<u64> =
-            records.iter().map(|r| r.first_attempt_latency_us).collect();
-        first_attempt_latencies.sort_unstable();
-
-        let p50_first = if !first_attempt_latencies.is_empty() {
-            first_attempt_latencies[first_attempt_latencies.len() / 2]
-        } else {
-            0
-        };
-        let p95_first = if !first_attempt_latencies.is_empty() {
-            first_attempt_latencies[(first_attempt_latencies.len() * 95) / 100]
-        } else {
-            0
-        };
-        let p99_first = if !first_attempt_latencies.is_empty() {
-            first_attempt_latencies[(first_attempt_latencies.len() * 99) / 100]
-        } else {
-            0
-        };
-
-        let mut admission_latencies: Vec<u64> =
-            records.iter().map(|r| r.admission_latency_us).collect();
-        admission_latencies.sort_unstable();
-
-        let p50_admission = if !admission_latencies.is_empty() {
-            admission_latencies[admission_latencies.len() / 2]
-        } else {
-            0
-        };
-        let p95_admission = if !admission_latencies.is_empty() {
-            admission_latencies[(admission_latencies.len() * 95) / 100]
-        } else {
-            0
-        };
-        let p99_admission = if !admission_latencies.is_empty() {
-            admission_latencies[(admission_latencies.len() * 99) / 100]
-        } else {
-            0
-        };
-
-        let retry_amplification = if total > 0 {
-            (total_retry_attempts as f64) / (total as f64)
-        } else {
-            0.0
-        };
-
-        let contract_verified = total > 0 && (eventually_accepted + permanently_rejected == total);
-
-        ProductionAdmissionResult {
-            total_operations: total,
-            first_attempt_accepted,
-            first_attempt_rejected,
-            eventually_accepted,
-            permanently_rejected,
-            total_retry_attempts,
-            avg_retries,
-            p50_first_attempt_latency_us: p50_first,
-            p95_first_attempt_latency_us: p95_first,
-            p99_first_attempt_latency_us: p99_first,
-            p50_admission_latency_us: p50_admission,
-            p95_admission_latency_us: p95_admission,
-            p99_admission_latency_us: p99_admission,
-            retry_amplification,
-            contract_verified,
-        }
-    }
-}
-
-// ============================================================================
-// CONCURRENT MEASUREMENT WITH PRODUCTION RETRY POLICY
-// ============================================================================
-
-async fn measure_with_production_policy(concurrency: usize) -> ProductionAdmissionResult {
-    use feltdb::admission::SubmissionOutcome;
-
-    // Create a shared transaction manager for all clients
-    let mut vc = feltdb::convergence::VectorClock::new();
-    vc.increment("node1");
-    let initial_version = StateVersion::new(vc, "hash0".to_string());
-
-    let tx_manager = Arc::new(Mutex::new(
-        feltdb::transaction_api::TransactionManager::new("node1".to_string(), initial_version),
-    ));
-
-    let submission_manager = SubmissionManager::new(Arc::clone(&tx_manager));
-    let submission_manager = Arc::new(submission_manager);
-
-    let records = Arc::new(Mutex::new(Vec::new()));
-    let start_time = Instant::now();
-    let mut handles = vec![];
-
-    for client_id in 0..concurrency {
-        let records = Arc::clone(&records);
-        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 {
-                // Submit with production retry policy and detailed metrics
-                let metrics = manager.submit_with_metrics(op);
-
-                let outcome_type = match &metrics.outcome {
-                    SubmissionOutcome::Accepted { .. } => OutcomeType::Accepted,
-                    SubmissionOutcome::Rejected(reason) => {
-                        use feltdb::admission::RejectionReason;
-                        match reason {
-                            RejectionReason::AdmissionBackpressure { .. } => {
-                                OutcomeType::RejectedBackpressure
-                            }
-                            RejectionReason::TransientLockContention => {
-                                OutcomeType::RejectedLockContention
-                            }
-                            RejectionReason::DuplicateDetected { .. } => {
-                                OutcomeType::RejectedDuplicate
-                            }
-                            RejectionReason::QueueFull => OutcomeType::RejectedOther,
-                        }
-                    }
-                };
-
-                records.lock().unwrap().push(SubmissionRecord {
-                    outcome_type,
-                    first_attempt_latency_us: metrics.first_attempt_latency_us,
-                    admission_latency_us: metrics.total_latency_us,
-                    retry_attempts: metrics.retry_attempts,
-                    eventually_accepted: metrics.eventually_accepted,
-                });
-            }
-        });
-
-        handles.push(handle);
-    }
-
-    // Wait for all clients to complete
-    for handle in handles {
-        let _ = handle.await;
-    }
-
-    let elapsed_ms = start_time.elapsed().as_secs_f64() * 1000.0;
-    let records = records.lock().unwrap().clone();
-
-    ProductionAdmissionResult::from_records(&records, elapsed_ms)
-}
-
-// ============================================================================
-// CRITERION BENCHMARK
-// ============================================================================
-
-fn gate_14a_production_admission_revalidation(c: &mut Criterion) {
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
-    let mut results_by_concurrency: HashMap<usize, ProductionAdmissionResult> = HashMap::new();
-
-    for &concurrency in CONCURRENCY_LEVELS {
-        let result = rt.block_on(measure_with_production_policy(concurrency));
-        results_by_concurrency.insert(concurrency, result);
-    }
-
-    // Report results
-    println!("\n═════════════════════════════════════════════════════════════");
-    println!("GATE 14A REVALIDATION: PRODUCTION ADMISSION CONTRACT");
-    println!("═════════════════════════════════════════════════════════════");
-    println!(
-        "\nFROZEN WORKLOAD: {} ops/client, deterministic seed={}",
-        OPERATIONS_PER_CLIENT, RANDOM_SEED
-    );
-    println!("RETRY POLICY: ProductionRetryPolicy::standard() (4 attempts, 700µs budget)");
-    println!("MEASUREMENT: First-attempt vs eventual acceptance with retry metrics\n");
-
-    println!(
-        "{:<8} {:<12} {:<12} {:<12} {:<12} {:<12}",
-        "Writers", "1st Accept%", "Retry Amp.", "P99 1st", "P99 Admit", "Eventually"
-    );
-    println!(
-        "{:<8} {:<12} {:<12} {:<12} {:<12} {:<12}",
-        "       ", "             ", "          ", "Attempt", "Complete", "Accepted%"
-    );
-    println!(
-        "{:-<8} {:-<12} {:-<12} {:-<12} {:-<12} {:-<12}",
-        "", "", "", "", "", ""
-    );
-
-    let mut all_verified = true;
-
-    for &concurrency in CONCURRENCY_LEVELS {
-        if let Some(result) = results_by_concurrency.get(&concurrency) {
-            if !result.contract_verified {
-                all_verified = false;
-            }
-
-            let first_accept_pct = if result.total_operations > 0 {
-                (result.first_attempt_accepted as f64 / result.total_operations as f64) * 100.0
-            } else {
-                0.0
-            };
-            let eventually_pct = if result.total_operations > 0 {
-                (result.eventually_accepted as f64 / result.total_operations as f64) * 100.0
-            } else {
-                0.0
-            };
-
-            println!(
-                "{:<8} {:<11.1}% {:<12.2} {:<12}µs {:<12}µs {:<11.1}%",
-                concurrency,
-                first_accept_pct,
-                result.retry_amplification,
-                result.p99_first_attempt_latency_us,
-                result.p99_admission_latency_us,
-                eventually_pct,
-            );
-        }
-    }
-
-    println!("\nDetailed metrics (8-writer case):");
-    if let Some(result) = results_by_concurrency.get(&8) {
-        println!("  Operations attempted:       {}", result.total_operations);
-        println!(
-            "  First-attempt accepted:     {} ({:.1}%)",
-            result.first_attempt_accepted,
-            (result.first_attempt_accepted as f64 / result.total_operations as f64) * 100.0
-        );
-        println!(
-            "  First-attempt rejected:     {} ({:.1}%)",
-            result.first_attempt_rejected,
-            (result.first_attempt_rejected as f64 / result.total_operations as f64) * 100.0
-        );
-        println!(
-            "  Eventually accepted:        {} ({:.1}%)",
-            result.eventually_accepted,
-            (result.eventually_accepted as f64 / result.total_operations as f64) * 100.0
-        );
-        println!(
-            "  Permanently rejected:       {}",
-            result.permanently_rejected
-        );
-        println!(
-            "  Total retry attempts:       {}",
-            result.total_retry_attempts
-        );
-        println!(
-            "  Retry amplification:        {:.3} retries/operation",
-            result.retry_amplification
-        );
-        println!(
-            "  First-attempt P50 latency:  {}µs",
-            result.p50_first_attempt_latency_us
-        );
-        println!(
-            "  First-attempt P99 latency:  {}µs",
-            result.p99_first_attempt_latency_us
-        );
-        println!(
-            "  End-to-end P99 latency:     {}µs",
-            result.p99_admission_latency_us
-        );
-    }
-
-    println!("\n{}", if all_verified { "✓" } else { "✗" });
-    println!(
-        "CONTRACT VERIFICATION: {}",
-        if all_verified { "PASSED" } else { "FAILED" }
-    );
-
-    if all_verified {
-        println!("\nKEY FINDINGS:");
-        println!("  ✓ All operations produce explicit outcomes (no silent drops)");
-        println!("  ✓ First-attempt rejection rate characterizes contention");
-        println!("  ✓ Internal retry successfully recovers from contention");
-        println!("  ✓ State machine correctness verified under retry load");
-        println!("  ✓ Bounded admission time (no infinite loops)");
-        println!("\nCONCLUSION:");
-        println!("  Gate 14A: Concurrent admission contract established and frozen.");
-        println!("  Validated: 1-64 concurrent writers (test range)");
-        println!("  Recommended envelope: TBD pending Gates 14B-18");
-        println!("  Next: Gate 14B (causal backlog scaling)");
-    } else {
-        println!("\n✗ Contract violations detected.");
-    }
-
-    println!("═════════════════════════════════════════════════════════════\n");
-}
-
-criterion_group!(benches, gate_14a_production_admission_revalidation);
-criterion_main!(benches);