@feltdb/core 0.13.0 → 0.16.0

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

@@ -1,531 +0,0 @@
-/// Gate 14A-SYNC: Synchronization Economics Measurement
-///
-/// Objective: Characterize the cost of the current mutex-based write path.
-/// Measure whether lock contention or critical-section work dominates.
-///
-/// FROZEN WORKLOAD (identical to Gate 14A/RC/RC2):
-/// - 1000 operations per client
-/// - 10,000 record dataset
-/// - 70% reads, 30% writes (seed: 42)
-/// - Consensus: Causal
-///
-/// MEASUREMENTS (across concurrency 1 → 2 → 4 → 8 → 16 → 32 → 64):
-/// - Lock acquisition attempts (try_lock calls)
-/// - Successful acquisitions (first try + retries)
-/// - Failed acquisitions (retry exhaustion)
-/// - Lock hold duration (critical section time)
-/// - Lock wait duration (retry loops, backoff time)
-/// - Operations per successful lock acquisition
-/// - Retry distribution (0, 1, 2, 3+ attempts)
-/// - Rejection rate (%)
-/// - Throughput (ops/sec)
-/// - p50/p95/p99 latencies
-///
-/// KEY ANALYSIS:
-/// Ratio = lock_wait_time / total_operation_time
-/// If ratio is high (lock dominates) → admission architecture is bottleneck
-/// If ratio is low (lock is cheap) → other subsystem is constrained
-use criterion::{criterion_group, criterion_main, Criterion};
-use feltdb::Operation;
-use serde_json::json;
-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, 8, 16, 32, 64];
-const TRIALS_PER_LEVEL: usize = 3;
-
-/// 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
-}
-
-// ============================================================================
-// LOCK ECONOMICS TRACKING
-// ============================================================================
-
-#[derive(Clone)]
-struct LockOperation {
-    op_id: u64,
-    operation_latency_us: u64,
-    lock_wait_us: u64,
-    lock_hold_us: u64,
-    acquisition_attempts: usize,
-    retry_count: usize,
-    success: bool,
-}
-
-#[derive(Clone, Default)]
-struct LockStatistics {
-    total_operations: usize,
-    successful_operations: usize,
-    rejected_operations: usize,
-    total_acquisition_attempts: usize,
-    total_lock_wait_us: u64,
-    total_lock_hold_us: u64,
-    ops_per_acquisition: f64,
-    retry_distribution: [usize; 5], // [0 retries, 1, 2, 3, 4+]
-    throughput_ops_per_sec: f64,
-    p50_operation_latency_us: u64,
-    p95_operation_latency_us: u64,
-    p99_operation_latency_us: u64,
-    lock_wait_ratio: f64,        // lock_wait_time / total_operation_time
-    critical_section_ratio: f64, // lock_hold_time / total_operation_time
-}
-
-impl LockStatistics {
-    fn from_operations(ops: &[LockOperation], wall_clock_ms: f64) -> Self {
-        let total = ops.len();
-        let successful = ops.iter().filter(|o| o.success).count();
-        let rejected = total - successful;
-
-        let total_attempts: usize = ops.iter().map(|o| o.acquisition_attempts).sum();
-        let total_wait: u64 = ops.iter().map(|o| o.lock_wait_us).sum();
-        let total_hold: u64 = ops.iter().map(|o| o.lock_hold_us).sum();
-
-        let ops_per_acq = if total_attempts > 0 {
-            successful as f64 / total_attempts as f64
-        } else {
-            0.0
-        };
-
-        // Retry distribution
-        let mut retry_dist = [0; 5];
-        for op in ops {
-            if op.success {
-                let idx = op.retry_count.min(4);
-                retry_dist[idx] += 1;
-            }
-        }
-
-        // Latency percentiles
-        let mut latencies: Vec<u64> = ops.iter().map(|o| o.operation_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 total_operation_time_us: u64 = ops.iter().map(|o| o.operation_latency_us).sum();
-        let throughput = if wall_clock_ms > 0.0 {
-            (successful as f64 / wall_clock_ms) * 1000.0
-        } else {
-            0.0
-        };
-
-        let wait_ratio = if total_operation_time_us > 0 {
-            total_wait as f64 / total_operation_time_us as f64
-        } else {
-            0.0
-        };
-
-        let hold_ratio = if total_operation_time_us > 0 {
-            total_hold as f64 / total_operation_time_us as f64
-        } else {
-            0.0
-        };
-
-        LockStatistics {
-            total_operations: total,
-            successful_operations: successful,
-            rejected_operations: rejected,
-            total_acquisition_attempts: total_attempts,
-            total_lock_wait_us: total_wait,
-            total_lock_hold_us: total_hold,
-            ops_per_acquisition: ops_per_acq,
-            retry_distribution: retry_dist,
-            throughput_ops_per_sec: throughput,
-            p50_operation_latency_us: p50,
-            p95_operation_latency_us: p95,
-            p99_operation_latency_us: p99,
-            lock_wait_ratio: wait_ratio,
-            critical_section_ratio: hold_ratio,
-        }
-    }
-}
-
-// ============================================================================
-// MEASUREMENT WITH LOCK INSTRUMENTATION
-// ============================================================================
-
-async fn measure_synchronization_economics(concurrency: usize) -> (LockStatistics, usize) {
-    let operation_log = Arc::new(tokio::sync::Mutex::new(Vec::new()));
-    let measurements = 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 meas = Arc::clone(&measurements);
-        let instance_id = format!("node_{}", client_id);
-
-        let handle = tokio::spawn(async move {
-            let operations = generate_frozen_workload(&instance_id, client_id);
-
-            for op in operations.iter() {
-                let op_id = op.op_id;
-                let op_start = Instant::now();
-                let mut total_wait_us = 0u64;
-                let mut total_hold_us = 0u64;
-                let mut acquisition_attempts = 0;
-                let mut retry_count = 0;
-                let mut success = false;
-
-                // Try once without waiting
-                let try_start = Instant::now();
-                if let Ok(mut log_guard) = log.try_lock() {
-                    let hold_start = Instant::now();
-                    log_guard.push(op.clone());
-                    total_hold_us = hold_start.elapsed().as_micros() as u64;
-                    acquisition_attempts = 1;
-                    success = true;
-                } else {
-                    // Record initial attempt failure
-                    total_wait_us += try_start.elapsed().as_micros() as u64;
-                    acquisition_attempts = 1;
-
-                    // Retry with exponential backoff (matching Gate 14A: 3 retries)
-                    for attempt in 1..=3 {
-                        let backoff_us = 100_u64 * (2_u64).saturating_pow(attempt as u32);
-                        let sleep_start = Instant::now();
-                        tokio::time::sleep(Duration::from_micros(backoff_us)).await;
-                        total_wait_us += sleep_start.elapsed().as_micros() as u64;
-
-                        let try_start = Instant::now();
-                        if let Ok(mut log_guard) = log.try_lock() {
-                            let hold_start = Instant::now();
-                            log_guard.push(op.clone());
-                            total_hold_us = hold_start.elapsed().as_micros() as u64;
-                            acquisition_attempts += 1;
-                            retry_count = attempt;
-                            success = true;
-                            break;
-                        } else {
-                            total_wait_us += try_start.elapsed().as_micros() as u64;
-                            acquisition_attempts += 1;
-                        }
-                    }
-                }
-
-                let operation_latency_us = op_start.elapsed().as_micros() as u64;
-
-                let lock_op = LockOperation {
-                    op_id,
-                    operation_latency_us,
-                    lock_wait_us: total_wait_us,
-                    lock_hold_us: total_hold_us,
-                    acquisition_attempts,
-                    retry_count,
-                    success,
-                };
-
-                {
-                    let mut m = meas.lock().await;
-                    m.push(lock_op);
-                }
-            }
-        });
-
-        handles.push(handle);
-    }
-
-    for handle in handles {
-        let _ = handle.await;
-    }
-
-    let wall_clock_ms = start_time.elapsed().as_secs_f64() * 1000.0;
-    let final_log = operation_log.lock().await;
-    let ingested_count = final_log.len();
-
-    let measurements_guard = measurements.lock().await;
-    let stats = LockStatistics::from_operations(&measurements_guard, wall_clock_ms);
-
-    (stats, ingested_count)
-}
-
-// ============================================================================
-// BENCHMARK HARNESS
-// ============================================================================
-
-fn gate_14a_sync_economics(c: &mut Criterion) {
-    let mut group = c.benchmark_group("gate14a_sync_economics");
-    group.sample_size(10);
-    group.measurement_time(Duration::from_secs(5));
-
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
-    println!("\n═══════════════════════════════════════════════════════════════════");
-    println!("Gate 14A-SYNC: Synchronization Economics Measurement");
-    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!("\nKEY MEASUREMENTS:");
-    println!("  • Lock acquisition attempts (try_lock calls)");
-    println!("  • Successful vs rejected acquisitions");
-    println!("  • Lock hold duration (critical section time)");
-    println!("  • Lock wait duration (retry + backoff)");
-    println!("  • Critical ratio = lock_hold_time / total_operation_time");
-    println!("  • Wait ratio = lock_wait_time / total_operation_time");
-    println!("\nINTERPRETATION:");
-    println!("  High wait ratio → admission contention is bottleneck");
-    println!("  High hold ratio → critical section work is bottleneck");
-    println!("\n───────────────────────────────────────────────────────────────────");
-
-    let mut all_results: Vec<(usize, LockStatistics)> = Vec::new();
-
-    println!("\nCONCURRENCY SCALING:");
-    println!(
-        "{:8} │ {:8} │ {:8} │ {:8} │ {:6} │ {:6} │ {:6} │ {:8}",
-        "Writers", "Success", "Rejected", "Attempts", "Wait%", "Hold%", "Ops/acq", "Ops/sec"
-    );
-    println!("{}", "─".repeat(87));
-
-    for &concurrency in CONCURRENCY_LEVELS {
-        let mut trial_stats = Vec::new();
-
-        for _trial in 0..TRIALS_PER_LEVEL {
-            let (stats, _) = rt.block_on(measure_synchronization_economics(concurrency));
-            trial_stats.push(stats);
-        }
-
-        // Average across trials
-        let avg_success: usize = trial_stats
-            .iter()
-            .map(|s| s.successful_operations)
-            .sum::<usize>()
-            / trial_stats.len();
-        let avg_rejected: usize = trial_stats
-            .iter()
-            .map(|s| s.rejected_operations)
-            .sum::<usize>()
-            / trial_stats.len();
-        let avg_attempts: usize = trial_stats
-            .iter()
-            .map(|s| s.total_acquisition_attempts)
-            .sum::<usize>()
-            / trial_stats.len();
-        let avg_wait_ratio: f64 =
-            trial_stats.iter().map(|s| s.lock_wait_ratio).sum::<f64>() / trial_stats.len() as f64;
-        let avg_hold_ratio: f64 = trial_stats
-            .iter()
-            .map(|s| s.critical_section_ratio)
-            .sum::<f64>()
-            / trial_stats.len() as f64;
-        let avg_ops_per_acq: f64 = trial_stats
-            .iter()
-            .map(|s| s.ops_per_acquisition)
-            .sum::<f64>()
-            / trial_stats.len() as f64;
-        let avg_throughput: f64 = trial_stats
-            .iter()
-            .map(|s| s.throughput_ops_per_sec)
-            .sum::<f64>()
-            / trial_stats.len() as f64;
-
-        println!(
-            "{:8} │ {:8} │ {:8} │ {:8} │ {:5.1}% │ {:5.1}% │ {:6.2} │ {:8.0}",
-            concurrency,
-            avg_success,
-            avg_rejected,
-            avg_attempts,
-            avg_wait_ratio * 100.0,
-            avg_hold_ratio * 100.0,
-            avg_ops_per_acq,
-            avg_throughput
-        );
-
-        // Store first trial for detailed analysis
-        all_results.push((concurrency, trial_stats[0].clone()));
-    }
-
-    println!("─────────────────────────────────────────────────────────────────");
-
-    // =========================================================================
-    // DETAILED ANALYSIS AT KEY CONCURRENCY POINTS
-    // =========================================================================
-
-    println!("\nDETAILED ANALYSIS:");
-    println!("\n┌─ Concurrency Boundary Analysis ─────────────────────────────────┐");
-
-    if let Some((_, stats_1)) = all_results.iter().find(|(c, _)| *c == 1) {
-        if let Some((_, stats_8)) = all_results.iter().find(|(c, _)| *c == 8) {
-            println!("│ Single writer (baseline):");
-            println!(
-                "│   Wait ratio: {:.2}% | Hold ratio: {:.2}% | Throughput: {:.0} ops/sec",
-                stats_1.lock_wait_ratio * 100.0,
-                stats_1.critical_section_ratio * 100.0,
-                stats_1.throughput_ops_per_sec
-            );
-            println!("│");
-            println!("│ Eight writers (scaling challenge):");
-            println!(
-                "│   Wait ratio: {:.2}% | Hold ratio: {:.2}% | Throughput: {:.0} ops/sec",
-                stats_8.lock_wait_ratio * 100.0,
-                stats_8.critical_section_ratio * 100.0,
-                stats_8.throughput_ops_per_sec
-            );
-            println!("│");
-
-            let wait_increase = stats_8.lock_wait_ratio / stats_1.lock_wait_ratio;
-            let hold_increase = stats_8.critical_section_ratio / stats_1.critical_section_ratio;
-
-            println!("│ Ratio increase from 1→8 writers:");
-            println!("│   Lock wait contention: {:.1}x", wait_increase);
-            println!("│   Critical section: {:.1}x", hold_increase);
-
-            if wait_increase > hold_increase * 2.0 {
-                println!("│");
-                println!("│ ⚠ BOTTLENECK IDENTIFIED:");
-                println!("│   Lock acquisition contention dominates");
-                println!("│   (wait ratio increase >> hold ratio increase)");
-            } else if hold_increase > wait_increase * 2.0 {
-                println!("│");
-                println!("│ ⚠ BOTTLENECK IDENTIFIED:");
-                println!("│   Critical section work dominates");
-                println!("│   (hold ratio increase >> wait ratio increase)");
-            } else {
-                println!("│");
-                println!("│ ✓ BALANCED CONTENTION:");
-                println!("│   Both lock wait and hold scale proportionally");
-            }
-        }
-    }
-
-    println!("└──────────────────────────────────────────────────────────────┘");
-
-    // =========================================================================
-    // RETRY DISTRIBUTION AT HIGH CONCURRENCY
-    // =========================================================================
-
-    println!("\nRETRY DISTRIBUTION (at 64 writers):");
-    if let Some((_, stats_64)) = all_results.iter().find(|(c, _)| *c == 64) {
-        let total_successful = stats_64.retry_distribution.iter().sum::<usize>();
-        if total_successful > 0 {
-            println!(
-                "  0 retries: {} ({:.1}%)",
-                stats_64.retry_distribution[0],
-                (stats_64.retry_distribution[0] as f64 / total_successful as f64) * 100.0
-            );
-            for i in 1..4 {
-                if stats_64.retry_distribution[i] > 0 {
-                    println!(
-                        "  {} retries: {} ({:.1}%)",
-                        i,
-                        stats_64.retry_distribution[i],
-                        (stats_64.retry_distribution[i] as f64 / total_successful as f64) * 100.0
-                    );
-                }
-            }
-        }
-    }
-
-    println!("\n───────────────────────────────────────────────────────────────────");
-    println!("SYNCHRONIZATION ECONOMICS SUMMARY:");
-    println!("───────────────────────────────────────────────────────────────────");
-    println!("\nBottleneck Analysis:");
-    println!("  If lock_wait_ratio grows faster than critical_section_ratio");
-    println!("    → Admission architecture is the bottleneck");
-    println!("    → Consider: bounded queue, batching, or actor model");
-    println!("    → Current mutex may not be appropriate for this concurrency");
-    println!("  ");
-    println!("  If critical_section_ratio grows faster than lock_wait_ratio");
-    println!("    → Critical section work is the bottleneck");
-    println!("    → Consider: reduce operations per transaction, lazy evaluation");
-    println!("    → Mutex is not the primary constraint");
-    println!("  ");
-    println!("  If both grow proportionally");
-    println!("    → Contention is unavoidable; consider load reduction");
-    println!("    → Or verify that behavior matches concurrency theory");
-
-    println!("\n═══════════════════════════════════════════════════════════════════\n");
-
-    group.finish();
-}
-
-criterion_group!(benches, gate_14a_sync_economics);
-criterion_main!(benches);