@feltdb/core 0.4.12 → 0.4.14

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

@@ -0,0 +1,513 @@
+/// 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::{Instant, Duration};
+
+// ============================================================================
+// 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);