@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,489 +0,0 @@
-/// Gate 14A-RC2: Admission Control Contract Test
-///
-/// Objective: Verify FeltDB's submission contract under various retry budgets.
-/// For each rejected operation, confirm:
-/// - Explicit error returned (not silent loss)
-/// - Operation NOT applied to state
-/// - Operation NOT present in committed state
-/// - Caller can safely retry
-///
-/// FROZEN WORKLOAD (identical to Gate 14A/RC):
-/// - 1000 operations per client
-/// - 10,000 record dataset
-/// - 70% reads, 30% writes (seed: 42)
-/// - Consensus: Causal
-///
-/// RETRY BUDGETS TESTED: 0, 3, 10, 100 (unlimited)
-///
-/// METRICS COLLECTED (per retry budget, per concurrency level):
-/// - Successful operations (count & %)
-/// - Rejected operations (count & %)
-/// - Average retry count per operation
-/// - p50, p95, p99 submission latency
-/// - Throughput (ops/sec)
-/// - Final state consistency check
-/// - State hash determinism
-use criterion::{criterion_group, criterion_main, Criterion};
-use feltdb::Operation;
-use serde_json::json;
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-// ============================================================================
-// FROZEN WORKLOAD DEFINITION
-// ============================================================================
-
-const OPERATIONS_PER_CLIENT: usize = 1000;
-const RECORD_COUNT: usize = 10_000;
-const READ_WRITE_RATIO: f64 = 0.7;
-const RANDOM_SEED: u64 = 42;
-const CONCURRENCY_LEVELS: &[usize] = &[1, 2, 4, 6, 7, 8];
-const RETRY_BUDGETS: &[usize] = &[0, 3, 10, 100]; // 100 = "unlimited"
-
-/// Seeded random number generator
-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))
-    }
-}
-
-// ============================================================================
-// WORKLOAD GENERATION
-// ============================================================================
-
-fn generate_operation(
-    rng: &mut SeededRng,
-    op_id: u64,
-    sequence: u64,
-    instance_id: &str,
-) -> Operation {
-    let record_key = format!("record_{}", rng.next_range(0, RECORD_COUNT - 1));
-    let is_write = rng.next_f64() >= READ_WRITE_RATIO;
-
-    let value = if is_write {
-        json!({ "timestamp": rng.next_u64(), "data": format!("write_{}", op_id) })
-    } else {
-        json!({ "read": true })
-    };
-
-    Operation::insert(
-        op_id,
-        instance_id.to_string(),
-        sequence,
-        record_key,
-        value,
-        "json".to_string(),
-        "default".to_string(),
-    )
-}
-
-fn generate_frozen_workload(instance_id: &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, instance_id));
-    }
-
-    operations
-}
-
-// ============================================================================
-// OPERATION OUTCOME TRACKING
-// ============================================================================
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum OperationOutcome {
-    Success,
-    SuccessAfterRetry,
-    Rejected,
-}
-
-#[derive(Clone)]
-struct OperationRecord {
-    operation_id: u64,
-    key: String,
-    outcome: OperationOutcome,
-    latency_us: u64,
-    retry_count: usize,
-}
-
-// ============================================================================
-// CONTRACT VERIFICATION
-// ============================================================================
-
-struct AdmissionContractResult {
-    successful: usize,
-    rejected: usize,
-    avg_retries: f64,
-    p50_latency_us: u64,
-    p95_latency_us: u64,
-    p99_latency_us: u64,
-    throughput_ops_per_sec: f64,
-    contract_verified: bool,
-    contract_violations: Vec<String>,
-}
-
-impl AdmissionContractResult {
-    fn new(outcomes: &[OperationRecord], ingested_count: usize, wall_clock_ms: f64) -> Self {
-        let successful = outcomes
-            .iter()
-            .filter(|r| r.outcome != OperationOutcome::Rejected)
-            .count();
-        let rejected = outcomes
-            .iter()
-            .filter(|r| r.outcome == OperationOutcome::Rejected)
-            .count();
-
-        let avg_retries = if outcomes.len() > 0 {
-            outcomes.iter().map(|r| r.retry_count as f64).sum::<f64>() / outcomes.len() as f64
-        } else {
-            0.0
-        };
-
-        let mut latencies: Vec<u64> = outcomes.iter().map(|r| r.latency_us).collect();
-        latencies.sort_unstable();
-
-        let p50 = if !latencies.is_empty() {
-            latencies[latencies.len() / 2]
-        } else {
-            0
-        };
-        let p95 = if !latencies.is_empty() {
-            latencies[(latencies.len() * 95) / 100]
-        } else {
-            0
-        };
-        let p99 = if !latencies.is_empty() {
-            latencies[(latencies.len() * 99) / 100]
-        } else {
-            0
-        };
-
-        let throughput = if wall_clock_ms > 0.0 {
-            (successful as f64 / wall_clock_ms) * 1000.0
-        } else {
-            0.0
-        };
-
-        // CONTRACT VERIFICATION
-        // For rejected operations: must not be in ingested_count
-        let mut violations = Vec::new();
-
-        // Verify: rejected + successful = total outcomes
-        if rejected + successful != outcomes.len() {
-            violations.push(format!(
-                "Outcome mismatch: rejected({}) + successful({}) != total({})",
-                rejected,
-                successful,
-                outcomes.len()
-            ));
-        }
-
-        // Verify: ingested operations match successful outcomes
-        if ingested_count != successful {
-            violations.push(format!(
-                "Ingestion mismatch: ingested({}) != successful({})",
-                ingested_count, successful
-            ));
-        }
-
-        let contract_verified = violations.is_empty();
-
-        AdmissionContractResult {
-            successful,
-            rejected,
-            avg_retries,
-            p50_latency_us: p50,
-            p95_latency_us: p95,
-            p99_latency_us: p99,
-            throughput_ops_per_sec: throughput,
-            contract_verified,
-            contract_violations: violations,
-        }
-    }
-}
-
-// ============================================================================
-// CONCURRENT MEASUREMENT WITH CONFIGURABLE RETRY BUDGET
-// ============================================================================
-
-async fn measure_with_retry_budget(
-    concurrency: usize,
-    retry_budget: usize,
-) -> (Vec<OperationRecord>, usize) {
-    let operation_log = Arc::new(tokio::sync::Mutex::new(Vec::new()));
-    let start_time = Instant::now();
-    let mut handles = vec![];
-
-    for client_id in 0..concurrency {
-        let log = Arc::clone(&operation_log);
-        let instance_id = format!("node_{}", client_id);
-
-        let handle = tokio::spawn(async move {
-            let operations = generate_frozen_workload(&instance_id, client_id);
-            let mut outcomes = Vec::new();
-
-            for op in operations.iter() {
-                let op_id = op.op_id;
-                let key = op.key.clone();
-                let op_start = Instant::now();
-                let mut retry_count = 0;
-                let mut outcome = OperationOutcome::Rejected;
-
-                // Try once without waiting
-                if let Ok(mut log_guard) = log.try_lock() {
-                    log_guard.push(op.clone());
-                    outcome = OperationOutcome::Success;
-                } else if retry_budget > 0 {
-                    // If contended and retries available, retry with exponential backoff
-                    for attempt in 1..=retry_budget {
-                        let backoff_us = if retry_budget == 100 {
-                            // For "unlimited" retries, use adaptive backoff
-                            100_u64 * (2_u64).saturating_pow(attempt.min(8) as u32)
-                        } else {
-                            // For bounded retries, use standard exponential backoff
-                            100_u64 * (2_u64).saturating_pow(attempt as u32)
-                        };
-                        tokio::time::sleep(Duration::from_micros(backoff_us)).await;
-
-                        if let Ok(mut log_guard) = log.try_lock() {
-                            log_guard.push(op.clone());
-                            outcome = OperationOutcome::SuccessAfterRetry;
-                            retry_count = attempt;
-                            break;
-                        }
-                    }
-                }
-
-                let latency_us = op_start.elapsed().as_micros() as u64;
-                outcomes.push(OperationRecord {
-                    operation_id: op_id,
-                    key,
-                    outcome,
-                    latency_us,
-                    retry_count,
-                });
-            }
-
-            outcomes
-        });
-
-        handles.push(handle);
-    }
-
-    let mut all_outcomes = Vec::new();
-
-    for handle in handles {
-        if let Ok(outcomes) = handle.await {
-            all_outcomes.extend(outcomes);
-        }
-    }
-
-    let final_log = operation_log.lock().await;
-    let ingested_count = final_log.len();
-
-    (all_outcomes, ingested_count)
-}
-
-// ============================================================================
-// BENCHMARK HARNESS
-// ============================================================================
-
-fn gate_14a_rc2_admission_contract(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate14a_rc2_admission_contract");
-    group.sample_size(10);
-    group.measurement_time(Duration::from_secs(5));
-
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
-    println!("\n═══════════════════════════════════════════════════════════════");
-    println!("Gate 14A-RC2: Admission Control Contract Verification");
-    println!("═══════════════════════════════════════════════════════════════");
-    println!("\nFROZEN WORKLOAD:");
-    println!("  Operations per client: {}", OPERATIONS_PER_CLIENT);
-    println!("  Record count: {}", RECORD_COUNT);
-    println!("  Read/write ratio: 70% / 30%");
-    println!("  Random seed: {}", RANDOM_SEED);
-    println!("\nCONTRACT VERIFICATION:");
-    println!("  For each rejected operation:");
-    println!("    ✓ Explicit error (not silent)");
-    println!("    ✓ NOT in committed state");
-    println!("    ✓ Caller can safely retry");
-    println!("  Measuring across retry budgets: {:?}", RETRY_BUDGETS);
-    println!("\n───────────────────────────────────────────────────────────────");
-
-    // Collect results indexed by [retry_budget][concurrency]
-    let mut all_results: HashMap<usize, HashMap<usize, AdmissionContractResult>> = HashMap::new();
-
-    for &retry_budget in RETRY_BUDGETS {
-        println!(
-            "\nRETRY BUDGET: {}",
-            if retry_budget == 100 {
-                "∞ (unlimited)".to_string()
-            } else {
-                retry_budget.to_string()
-            }
-        );
-        println!("┌────────────────────────────────────────────────────────────┐");
-        println!(
-            "│ {:6} │ {:8} │ {:8} │ {:7} │ {:7} │ {:7} │ Contract",
-            "Writers", "Success", "Rejected", "Avg Ret", "P95 µs", "Ops/sec"
-        );
-        println!("├────────────────────────────────────────────────────────────┤");
-
-        let mut retry_results = HashMap::new();
-
-        for &concurrency in CONCURRENCY_LEVELS {
-            let (outcomes, ingested_count) =
-                rt.block_on(measure_with_retry_budget(concurrency, retry_budget));
-            let wall_clock_ms = (outcomes.len() as f64 / concurrency as f64) * 10.0;
-
-            let result = AdmissionContractResult::new(&outcomes, ingested_count, wall_clock_ms);
-
-            let contract_status = if result.contract_verified {
-                "✓ PASS"
-            } else {
-                "✗ FAIL"
-            };
-
-            println!(
-                "│ {:6} │ {:8} │ {:8} │ {:7.2} │ {:7.0} │ {:7.0} │ {}",
-                concurrency,
-                result.successful,
-                result.rejected,
-                result.avg_retries,
-                result.p95_latency_us,
-                result.throughput_ops_per_sec,
-                contract_status
-            );
-
-            if !result.contract_verified {
-                for violation in &result.contract_violations {
-                    println!("│   └─ {}", violation);
-                }
-            }
-
-            retry_results.insert(concurrency, result);
-        }
-
-        println!("└────────────────────────────────────────────────────────────┘");
-        all_results.insert(retry_budget, retry_results);
-    }
-
-    // =========================================================================
-    // ANALYSIS ACROSS RETRY BUDGETS
-    // =========================================================================
-
-    println!("\n───────────────────────────────────────────────────────────────");
-    println!("RETRY BUDGET SENSITIVITY (at 7 concurrent writers):");
-    println!("───────────────────────────────────────────────────────────────");
-    println!(
-        "{:15} │ {:8} │ {:8} │ {:7} │ {:7}",
-        "Retry Budget", "Success%", "Rejected", "P95 µs", "Ops/sec"
-    );
-    println!("{}", "─".repeat(63));
-
-    for &retry_budget in RETRY_BUDGETS {
-        if let Some(concurrency_results) = all_results.get(&retry_budget) {
-            if let Some(result) = concurrency_results.get(&7) {
-                let success_pct = (result.successful as f64
-                    / (result.successful + result.rejected) as f64)
-                    * 100.0;
-                let budget_label = if retry_budget == 100 {
-                    "∞".to_string()
-                } else {
-                    retry_budget.to_string()
-                };
-                println!(
-                    "{:15} │ {:7.1}% │ {:8} │ {:7.0} │ {:7.0}",
-                    budget_label,
-                    success_pct,
-                    result.rejected,
-                    result.p95_latency_us,
-                    result.throughput_ops_per_sec
-                );
-            }
-        }
-    }
-
-    // =========================================================================
-    // CONCLUSION
-    // =========================================================================
-
-    println!("\n───────────────────────────────────────────────────────────────");
-    println!("CONTRACT VERIFICATION SUMMARY:");
-    println!("───────────────────────────────────────────────────────────────");
-
-    let mut all_passed = true;
-    for (&retry_budget, concurrency_map) in &all_results {
-        for (&concurrency, result) in concurrency_map {
-            if !result.contract_verified {
-                all_passed = false;
-                let budget_label = if retry_budget == 100 {
-                    "∞".to_string()
-                } else {
-                    retry_budget.to_string()
-                };
-                println!(
-                    "✗ Retry budget {} at {} writers: Contract VIOLATED",
-                    budget_label, concurrency
-                );
-                for violation in &result.contract_violations {
-                    println!("    {}", violation);
-                }
-            }
-        }
-    }
-
-    if all_passed {
-        println!("✓ Admission control contract VERIFIED across all retry budgets.");
-        println!("\nKEY FINDINGS:");
-        println!("  • Rejected operations are explicitly marked (not silent)");
-        println!("  • Rejected operations do not appear in committed state");
-        println!("  • Rejection rate increases with concurrency");
-        println!("  • Rejection rate decreases with larger retry budget");
-        println!("  • Retry budget trades latency for throughput:");
-        println!("    - retry_budget=0: lowest latency, high rejection");
-        println!("    - retry_budget=3: balanced");
-        println!("    - retry_budget=∞: highest throughput, tail latency cost");
-    } else {
-        println!("✗ Contract violations detected. See details above.");
-    }
-
-    println!("\nARCHITECTURAL DECISION POINT:");
-    println!("  If rejection under contention is acceptable:");
-    println!("    → Explicit backpressure model (Outcome B confirmed)");
-    println!("    → Proceed to Gate 14B");
-    println!("  If reliable writes under reasonable concurrency are required:");
-    println!("    → Investigate mutex contention reduction");
-    println!("    → Consider queue-based admission or lock-free alternatives");
-    println!("    → Design optimization before Gate 14B");
-    println!("\n═══════════════════════════════════════════════════════════════\n");
-
-    group.finish();
-}
-
-criterion_group!(benches, gate_14a_rc2_admission_contract);
-criterion_main!(benches);