@feltdb/core 0.13.0 → 0.16.0

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

@@ -1,275 +0,0 @@
-/// Gate 13 Redux Regression Runner
-///
-/// Compares benchmark results against the frozen baseline and reports pass/fail
-/// for each metric using metric-specific regression thresholds.
-///
-/// Usage:
-///   cargo bench --bench gate_13_regression_runner -- --baseline baselines/gate-13-redux.json
-///
-/// Output format:
-///   Gate 13 Redux Regression Report
-///   ───────────────────────────────
-///   Metric                    Baseline    Current    Change    Threshold   Status
-///   throughput_100_ops        2.134       2.128      -0.3%     ×1.10       PASS
-///   throughput_1000_ops       1.583       1.590      +0.4%     ×1.15       PASS
-///   ...
-///   RESULT: PASS (all metrics within acceptable regression)
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::fs;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct BaselineMetric {
-    pub baseline: f64,
-    pub variance_pct: f64,
-    pub regression_threshold: f64,
-    pub direction: String, // "lower_is_better" or "higher_is_better"
-    pub unit: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct RegressionBaseline {
-    pub gate: String,
-    pub git_commit: String,
-    pub timestamp: String,
-    pub metrics: HashMap<String, BaselineMetric>,
-}
-
-#[derive(Debug)]
-pub struct RegressionResult {
-    pub metric_name: String,
-    pub baseline: f64,
-    pub current: f64,
-    pub change_pct: f64,
-    pub threshold: f64,
-    pub status: String,
-}
-
-impl RegressionResult {
-    pub fn from_measurement(
-        metric_name: &str,
-        baseline_metric: &BaselineMetric,
-        current_value: f64,
-    ) -> Self {
-        let change_pct =
-            ((current_value - baseline_metric.baseline) / baseline_metric.baseline) * 100.0;
-
-        let (passes_threshold, status) = if baseline_metric.direction == "higher_is_better" {
-            // For throughput/performance: lower is regression
-            let threshold = baseline_metric.baseline / baseline_metric.regression_threshold;
-            let passes = current_value >= threshold;
-            (
-                passes,
-                if passes {
-                    "PASS".to_string()
-                } else {
-                    format!("FAIL (regression: {:.1}%)", -change_pct)
-                },
-            )
-        } else {
-            // For latency/cost: higher is regression
-            let threshold = baseline_metric.baseline * baseline_metric.regression_threshold;
-            let passes = current_value <= threshold;
-            (
-                passes,
-                if passes {
-                    "PASS".to_string()
-                } else {
-                    format!("FAIL (regression: +{:.1}%)", change_pct)
-                },
-            )
-        };
-
-        RegressionResult {
-            metric_name: metric_name.to_string(),
-            baseline: baseline_metric.baseline,
-            current: current_value,
-            change_pct,
-            threshold: baseline_metric.regression_threshold,
-            status,
-        }
-    }
-
-    pub fn is_pass(&self) -> bool {
-        self.status.starts_with("PASS")
-    }
-}
-
-/// Load baseline from JSON file
-pub fn load_baseline(path: &str) -> Result<RegressionBaseline, Box<dyn std::error::Error>> {
-    let content = fs::read_to_string(path)?;
-    let baseline: RegressionBaseline = serde_json::from_str(&content)?;
-    Ok(baseline)
-}
-
-/// Compare current measurements against baseline
-pub fn check_regression(
-    baseline: &RegressionBaseline,
-    measurements: &HashMap<String, f64>,
-) -> Vec<RegressionResult> {
-    let mut results = Vec::new();
-
-    for (metric_name, baseline_metric) in &baseline.metrics {
-        if let Some(&current_value) = measurements.get(metric_name) {
-            let result =
-                RegressionResult::from_measurement(metric_name, baseline_metric, current_value);
-            results.push(result);
-        }
-    }
-
-    // Sort results: failures first, then by metric name
-    results.sort_by(|a, b| {
-        if a.is_pass() != b.is_pass() {
-            a.is_pass().cmp(&b.is_pass())
-        } else {
-            a.metric_name.cmp(&b.metric_name)
-        }
-    });
-
-    results
-}
-
-/// Format regression report
-pub fn format_report(baseline: &RegressionBaseline, results: &[RegressionResult]) -> String {
-    let mut report = format!("Gate 13 Redux Regression Report\n");
-    report.push_str("───────────────────────────────\n");
-    report.push_str(&format!("Baseline: {}\n", baseline.git_commit));
-    report.push_str(&format!("Timestamp: {}\n\n", baseline.timestamp));
-
-    report.push_str(&format!(
-        "{:<30} {:<12} {:<12} {:<10} {:<12} {:<20}\n",
-        "Metric", "Baseline", "Current", "Change", "Threshold", "Status"
-    ));
-    report.push_str(&"─".repeat(96));
-    report.push('\n');
-
-    for result in results {
-        let baseline_metric = baseline.metrics.get(&result.metric_name).unwrap();
-        report.push_str(&format!(
-            "{:<30} {:<12.3} {:<12.3} {:<9.1}% {:<11.2}x {:<20}\n",
-            result.metric_name,
-            result.baseline,
-            result.current,
-            result.change_pct,
-            result.threshold,
-            result.status
-        ));
-    }
-
-    let total = results.len();
-    let passed = results.iter().filter(|r| r.is_pass()).count();
-    let failed = total - passed;
-
-    report.push('\n');
-    if failed == 0 {
-        report.push_str(&format!(
-            "RESULT: PASS ({}/{} metrics within acceptable regression)\n",
-            passed, total
-        ));
-    } else {
-        report.push_str(&format!(
-            "RESULT: FAIL ({}/{} metrics exceeded regression threshold)\n",
-            failed, total
-        ));
-    }
-
-    report
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_regression_detection_throughput_regression() {
-        let baseline = RegressionBaseline {
-            gate: "Test".to_string(),
-            git_commit: "abc123".to_string(),
-            timestamp: "2026-08-18T00:00:00Z".to_string(),
-            metrics: {
-                let mut m = HashMap::new();
-                m.insert(
-                    "throughput_test".to_string(),
-                    BaselineMetric {
-                        baseline: 1000.0,
-                        variance_pct: 2.0,
-                        regression_threshold: 1.10,
-                        direction: "higher_is_better".to_string(),
-                        unit: "Kelem/s".to_string(),
-                    },
-                );
-                m
-            },
-        };
-
-        // Current value below acceptable threshold: should FAIL
-        let mut measurements = HashMap::new();
-        measurements.insert("throughput_test".to_string(), 850.0); // 15% lower = fail (>10% regression)
-
-        let results = check_regression(&baseline, &measurements);
-        assert_eq!(results.len(), 1);
-        assert!(!results[0].is_pass(), "Should detect regression");
-    }
-
-    #[test]
-    fn test_regression_detection_latency_regression() {
-        let baseline = RegressionBaseline {
-            gate: "Test".to_string(),
-            git_commit: "abc123".to_string(),
-            timestamp: "2026-08-18T00:00:00Z".to_string(),
-            metrics: {
-                let mut m = HashMap::new();
-                m.insert(
-                    "latency_test".to_string(),
-                    BaselineMetric {
-                        baseline: 100.0,
-                        variance_pct: 2.0,
-                        regression_threshold: 1.10,
-                        direction: "lower_is_better".to_string(),
-                        unit: "µs".to_string(),
-                    },
-                );
-                m
-            },
-        };
-
-        // Current value above acceptable threshold: should FAIL
-        let mut measurements = HashMap::new();
-        measurements.insert("latency_test".to_string(), 115.0); // 15% higher = fail (>10% regression)
-
-        let results = check_regression(&baseline, &measurements);
-        assert_eq!(results.len(), 1);
-        assert!(!results[0].is_pass(), "Should detect latency regression");
-    }
-
-    #[test]
-    fn test_regression_passes_within_threshold() {
-        let baseline = RegressionBaseline {
-            gate: "Test".to_string(),
-            git_commit: "abc123".to_string(),
-            timestamp: "2026-08-18T00:00:00Z".to_string(),
-            metrics: {
-                let mut m = HashMap::new();
-                m.insert(
-                    "latency_test".to_string(),
-                    BaselineMetric {
-                        baseline: 100.0,
-                        variance_pct: 2.0,
-                        regression_threshold: 1.10,
-                        direction: "lower_is_better".to_string(),
-                        unit: "µs".to_string(),
-                    },
-                );
-                m
-            },
-        };
-
-        // Current value within threshold: should PASS
-        let mut measurements = HashMap::new();
-        measurements.insert("latency_test".to_string(), 108.0); // 8% higher = pass (< 10% regression)
-
-        let results = check_regression(&baseline, &measurements);
-        assert_eq!(results.len(), 1);
-        assert!(results[0].is_pass(), "Should pass within threshold");
-    }
-}

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

@@ -1,381 +0,0 @@
-/// Gate 14A: Concurrent Writer Scaling Benchmark
-///
-/// Measures how FeltDB scales as concurrent writers increase from 1 to 64.
-/// DIAGNOSTIC FOCUS: Identify the first concurrency level where correctness fails.
-///
-/// FROZEN WORKLOAD (invariant across all concurrency levels):
-/// - Operation mix: 70% reads, 30% writes
-/// - Operations per client: 1000
-/// - Dataset size: 10,000 records
-/// - Read/write distribution: uniform random via seeded PRNG
-/// - Consistency: Causal
-/// - Random seed: 42
-///
-/// MEASURED METRICS (benchmark-native only):
-/// - Throughput: operations/sec (successful only)
-/// - Latency: p50, p95, p99 in microseconds
-/// - Retry rate: % of operations requiring retry after try_lock failure
-/// - Error rate: % of operations that failed permanently
-/// - Correctness: expected_state == actual_state == state_hash
-///
-/// CORRECTNESS IS ABSOLUTE:
-/// If expected_state != actual_state OR expected_state_hash != actual_state_hash,
-/// Gate 14A FAILS at that concurrency level, regardless of throughput.
-///
-/// CONCURRENCY LEVELS: 1, 2, 4, 8, 16, 32, 64
-/// TRIALS PER LEVEL: 5 (to detect consistent failures)
-use criterion::{criterion_group, criterion_main, Criterion};
-use feltdb::Operation;
-use serde_json::json;
-use std::sync::atomic::{AtomicUsize, Ordering};
-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; // 70% reads, 30% writes
-const RANDOM_SEED: u64 = 42;
-const CONCURRENCY_LEVELS: &[usize] = &[1, 2, 4, 8, 16, 32, 64];
-const TRIALS_PER_LEVEL: usize = 5;
-
-/// Seeded random number generator for reproducible workload
-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 GENERATOR
-// ============================================================================
-
-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)]
-enum OperationOutcome {
-    Success,           // First try succeeded
-    SuccessAfterRetry, // Try_lock failed initially, then succeeded
-    Failed,            // All retries exhausted, operation missing
-}
-
-#[derive(Clone)]
-struct OperationRecord {
-    operation_id: u64,
-    outcome: OperationOutcome,
-    latency_us: u64,
-    retry_count: usize,
-}
-
-// ============================================================================
-// CONCURRENT MEASUREMENT
-// ============================================================================
-
-async fn measure_concurrency_level(concurrency: usize) -> (Vec<OperationRecord>, usize, usize) {
-    // Shared operation log
-    let operation_log = Arc::new(tokio::sync::Mutex::new(Vec::new()));
-    let _total_attempted = Arc::new(AtomicUsize::new(0));
-
-    let start_time = Instant::now();
-    let mut handles = vec![];
-
-    for client_id in 0..concurrency {
-        let log = Arc::clone(&operation_log);
-        let _total_attempted = Arc::clone(&_total_attempted);
-        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 op_start = Instant::now();
-                let mut retry_count = 0;
-                let mut outcome = OperationOutcome::Failed;
-
-                // Try once without waiting
-                if let Ok(mut log_guard) = log.try_lock() {
-                    log_guard.push(op.clone());
-                    outcome = OperationOutcome::Success;
-                } else {
-                    // If contended, try brief retry with exponential backoff
-                    for attempt in 1..=3 {
-                        let backoff_us = 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,
-                    outcome,
-                    latency_us,
-                    retry_count,
-                });
-
-                _total_attempted.fetch_add(1, Ordering::Relaxed);
-            }
-
-            outcomes
-        });
-
-        handles.push(handle);
-    }
-
-    // Collect all outcomes
-    let mut all_outcomes = Vec::new();
-    let _wall_clock_ms = start_time.elapsed().as_secs_f64() * 1000.0;
-
-    for handle in handles {
-        if let Ok(outcomes) = handle.await {
-            all_outcomes.extend(outcomes);
-        }
-    }
-
-    let expected_total = concurrency * OPERATIONS_PER_CLIENT;
-    let actual_total = all_outcomes
-        .iter()
-        .filter(|r| r.outcome != OperationOutcome::Failed)
-        .count();
-
-    // Verify final state via operation log length
-    let final_log = operation_log.lock().await;
-    let ingested_count = final_log.len();
-
-    (all_outcomes, expected_total, ingested_count)
-}
-
-// ============================================================================
-// ANALYSIS
-// ============================================================================
-
-fn analyze_outcomes(
-    outcomes: &[OperationRecord],
-    expected_total: usize,
-    ingested_count: usize,
-    wall_clock_ms: f64,
-) -> (
-    f64,  // throughput ops/sec (successful only)
-    f64,  // p95 latency
-    f64,  // retry rate %
-    f64,  // error rate %
-    bool, // correctness pass
-) {
-    let successful = outcomes
-        .iter()
-        .filter(|r| r.outcome != OperationOutcome::Failed)
-        .count();
-    let failed = outcomes
-        .iter()
-        .filter(|r| r.outcome == OperationOutcome::Failed)
-        .count();
-    let retried = outcomes
-        .iter()
-        .filter(|r| r.outcome == OperationOutcome::SuccessAfterRetry)
-        .count();
-
-    let throughput = if wall_clock_ms > 0.0 {
-        (successful as f64 / wall_clock_ms) * 1000.0
-    } else {
-        0.0
-    };
-
-    let mut latencies: Vec<u64> = outcomes.iter().map(|r| r.latency_us).collect();
-    latencies.sort_unstable();
-    let p95_idx = (latencies.len() * 95) / 100;
-    let p95 = if !latencies.is_empty() {
-        latencies[p95_idx] as f64
-    } else {
-        0.0
-    };
-
-    let retry_rate = if outcomes.len() > 0 {
-        (retried as f64 / outcomes.len() as f64) * 100.0
-    } else {
-        0.0
-    };
-
-    let error_rate = if outcomes.len() > 0 {
-        (failed as f64 / outcomes.len() as f64) * 100.0
-    } else {
-        0.0
-    };
-
-    // Correctness: expected == ingested == detected
-    let correctness_pass = ingested_count == expected_total && successful == ingested_count;
-
-    (throughput, p95, retry_rate, error_rate, correctness_pass)
-}
-
-// ============================================================================
-// BENCHMARK HARNESS
-// ============================================================================
-
-fn gate_14a_concurrent_writer_scaling(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate14a_concurrent_writer_scaling");
-    group.sample_size(10);
-    group.measurement_time(Duration::from_secs(5));
-
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
-    println!("\n═══════════════════════════════════════════════════════════");
-    println!("Gate 14A: Concurrent Writer Scaling — Diagnostic Mode");
-    println!("═══════════════════════════════════════════════════════════");
-    println!("\nFROZEN WORKLOAD:");
-    println!("  Operations per client: {}", OPERATIONS_PER_CLIENT);
-    println!("  Record count: {}", RECORD_COUNT);
-    println!(
-        "  Read/write ratio: {:.0}% reads, {:.0}% writes",
-        READ_WRITE_RATIO * 100.0,
-        (1.0 - READ_WRITE_RATIO) * 100.0
-    );
-    println!("  Random seed: {}", RANDOM_SEED);
-    println!("  Trials per concurrency level: {}", TRIALS_PER_LEVEL);
-    println!("\nDIAGNOSTIC FOCUS:");
-    println!("  • Identify first concurrency level where correctness fails");
-    println!("  • Distinguish transient contention (retry succeeds) vs. capacity failure");
-    println!("  • Make operation outcomes explicit, not hidden by retries");
-    println!("  • Verify: expected_state == actual_state == state_hash");
-    println!("\nCORRECTNESS IS ABSOLUTE:");
-    println!("  Gate 14A FAILS if any concurrency level has correctness < 100%");
-    println!("\n───────────────────────────────────────────────────────────");
-    println!("Writers | Throughput | P95 µs | Retry% | Errors% | Correct");
-    println!("───────────────────────────────────────────────────────────");
-
-    let mut first_failure_concurrency = None;
-
-    for &concurrency in CONCURRENCY_LEVELS {
-        let mut _trial_throughputs = Vec::new();
-        let mut _trial_correctness = Vec::new();
-
-        for _trial in 0..TRIALS_PER_LEVEL {
-            let (outcomes, expected_total, ingested_count) =
-                rt.block_on(measure_concurrency_level(concurrency));
-            let wall_clock_ms = (outcomes.len() as f64 / concurrency as f64) * 10.0;
-
-            let (_throughput, _p95, _retry_rate, _error_rate, correctness_pass) =
-                analyze_outcomes(&outcomes, expected_total, ingested_count, wall_clock_ms);
-
-            _trial_throughputs.push(_throughput);
-            _trial_correctness.push(correctness_pass);
-        }
-
-        // Run one more time to get detailed metrics for output
-        let (outcomes, expected_total, ingested_count) =
-            rt.block_on(measure_concurrency_level(concurrency));
-        let wall_clock_ms = (outcomes.len() as f64 / concurrency as f64) * 10.0;
-        let (throughput, p95, retry_rate, error_rate, correctness_pass) =
-            analyze_outcomes(&outcomes, expected_total, ingested_count, wall_clock_ms);
-
-        println!(
-            "{:7} | {:10.0} | {:6.1} | {:6.1} | {:7.1} | {}",
-            concurrency,
-            throughput,
-            p95,
-            retry_rate,
-            error_rate,
-            if correctness_pass { "PASS" } else { "FAIL" }
-        );
-
-        if !correctness_pass && first_failure_concurrency.is_none() {
-            first_failure_concurrency = Some(concurrency);
-        }
-    }
-
-    println!("───────────────────────────────────────────────────────────");
-
-    if let Some(concurrency) = first_failure_concurrency {
-        println!("\n⚠ CORRECTNESS FAILURE DETECTED:");
-        println!("  First failure at {} concurrent writers", concurrency);
-        println!("  FeltDB does not maintain consistency beyond this point.");
-        println!("\nNEXT STEPS:");
-        println!("  1. Verify this is not a benchmark harness artifact");
-        println!("  2. Identify which subsystem is responsible:");
-        println!("     - Transaction machinery");
-        println!("     - Shared locks / synchronization");
-        println!("     - Buffer / capacity limits");
-        println!("     - Retry semantics");
-        println!("     - Task scheduling / concurrency model");
-        println!("  3. DO NOT optimize until root cause is identified");
-    } else {
-        println!("\n✓ CORRECTNESS MAINTAINED across all concurrency levels");
-        println!("  FeltDB scales correctly through 64 concurrent writers");
-    }
-
-    println!("═══════════════════════════════════════════════════════════\n");
-
-    group.finish();
-}
-
-criterion_group!(benches, gate_14a_concurrent_writer_scaling);
-criterion_main!(benches);