foxhunt/services/trading_service/examples/latency_demo.rs

//! Demonstration of sub-50μs latency validation system
//!
//! This example shows how the hdrhistogram-based latency recorder works
//! and validates P50/P95/P99 measurements for trading operations.

use hdrhistogram::Histogram;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

/// Simplified latency categories for demo
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum LatencyCategory {
    OrderSubmission,
    RiskValidation,
    OrderProcessing,
    EndToEndOrder,
}

impl LatencyCategory {
    fn name(&self) -> &'static str {
        match self {
            Self::OrderSubmission => "order_submission",
            Self::RiskValidation => "risk_validation",
            Self::OrderProcessing => "order_processing",
            Self::EndToEndOrder => "end_to_end_order",
        }
    }
}

/// Demo latency recorder
struct DemoLatencyRecorder {
    histograms: Arc<Mutex<HashMap<LatencyCategory, Histogram<u64>>>>,
}

impl DemoLatencyRecorder {
    fn new() -> Self {
        Self {
            histograms: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    fn record(&self, category: LatencyCategory, latency_ns: u64) {
        let mut histograms = self.histograms.lock().unwrap();
        let histogram = histograms.entry(category).or_insert_with(|| {
            Histogram::new_with_bounds(1, 10_000_000, 3).expect("Failed to create histogram")
        });

        if let Err(e) = histogram.record(latency_ns) {
            println!("Failed to record latency: {}", e);
        }
    }

    fn get_stats(&self, category: LatencyCategory) -> Option<LatencyStats> {
        let histograms = self.histograms.lock().unwrap();
        histograms.get(&category).map(|histogram| LatencyStats {
            count: histogram.len(),
            p50_ns: histogram.value_at_quantile(0.50),
            p95_ns: histogram.value_at_quantile(0.95),
            p99_ns: histogram.value_at_quantile(0.99),
        })
    }

    fn generate_report(&self) -> Vec<(LatencyCategory, LatencyStats)> {
        let histograms = self.histograms.lock().unwrap();
        let mut results = Vec::new();

        for (&category, histogram) in histograms.iter() {
            if histogram.len() > 0 {
                let stats = LatencyStats {
                    count: histogram.len(),
                    p50_ns: histogram.value_at_quantile(0.50),
                    p95_ns: histogram.value_at_quantile(0.95),
                    p99_ns: histogram.value_at_quantile(0.99),
                };
                results.push((category, stats));
            }
        }

        results
    }
}

#[derive(Debug)]
struct LatencyStats {
    count: u64,
    p50_ns: u64,
    p95_ns: u64,
    p99_ns: u64,
}

impl LatencyStats {
    fn p50_us(&self) -> f64 {
        self.p50_ns as f64 / 1_000.0
    }
    fn p95_us(&self) -> f64 {
        self.p95_ns as f64 / 1_000.0
    }
    fn p99_us(&self) -> f64 {
        self.p99_ns as f64 / 1_000.0
    }
    fn meets_target(&self, target_us: f64) -> bool {
        self.p99_us() <= target_us
    }
}

fn simulate_cpu_work(duration: Duration) {
    let start = Instant::now();
    let mut counter = 0u64;

    while start.elapsed() < duration {
        counter = counter.wrapping_add(1);
    }

    // Prevent optimization
    if counter == u64::MAX {
        println!("Unlikely: {}", counter);
    }
}

fn simulate_trading_operation(recorder: &DemoLatencyRecorder, _iteration: u64) {
    // End-to-end timing
    let end_to_end_start = Instant::now();

    // Order submission (5μs target)
    let submission_start = Instant::now();
    simulate_cpu_work(Duration::from_nanos(5_000));
    recorder.record(
        LatencyCategory::OrderSubmission,
        submission_start.elapsed().as_nanos() as u64,
    );

    // Risk validation (8μs target)
    let risk_start = Instant::now();
    simulate_cpu_work(Duration::from_nanos(8_000));
    recorder.record(
        LatencyCategory::RiskValidation,
        risk_start.elapsed().as_nanos() as u64,
    );

    // Order processing (12μs target)
    let processing_start = Instant::now();
    simulate_cpu_work(Duration::from_nanos(12_000));
    recorder.record(
        LatencyCategory::OrderProcessing,
        processing_start.elapsed().as_nanos() as u64,
    );

    // Record end-to-end
    recorder.record(
        LatencyCategory::EndToEndOrder,
        end_to_end_start.elapsed().as_nanos() as u64,
    );
}

fn main() {
    println!("🚀 Foxhunt Trading Service - Sub-50μs Latency Validation Demo");
    println!("==============================================================");

    let recorder = DemoLatencyRecorder::new();
    let target_us = 50.0;
    let iterations = 10_000;

    println!("Running {} trading operations...", iterations);
    println!("Target P99 latency: {}μs", target_us);
    println!();

    // Warm-up
    println!("Warming up...");
    for i in 0..1000 {
        simulate_trading_operation(&recorder, i);
    }

    // Clear warm-up data and start fresh
    let recorder = DemoLatencyRecorder::new();

    // Main test
    println!("Running main performance test...");
    let test_start = Instant::now();

    for i in 0..iterations {
        simulate_trading_operation(&recorder, i);

        if (i + 1) % 1000 == 0 {
            println!("  Completed {} operations...", i + 1);
        }
    }

    let test_duration = test_start.elapsed();
    let ops_per_sec = iterations as f64 / test_duration.as_secs_f64();

    println!();
    println!("📊 PERFORMANCE RESULTS");
    println!("======================");
    println!("Test completed in {:.2}s", test_duration.as_secs_f64());
    println!("Throughput: {:.0} operations/second", ops_per_sec);
    println!();

    // Generate detailed report
    let results = recorder.generate_report();
    let mut all_targets_met = true;
    let mut passed_categories = 0;

    println!("📈 LATENCY ANALYSIS");
    println!("===================");

    for (category, stats) in &results {
        let target_met = stats.meets_target(target_us);
        let status = if target_met { "✅ PASS" } else { "❌ FAIL" };

        if target_met {
            passed_categories += 1;
        } else {
            all_targets_met = false;
        }

        println!("{} {} ({} samples):", status, category.name(), stats.count);
        println!(
            "  P50: {:.1}μs | P95: {:.1}μs | P99: {:.1}μs",
            stats.p50_us(),
            stats.p95_us(),
            stats.p99_us()
        );
    }

    println!();
    println!("🎯 FINAL RESULTS");
    println!("================");

    if all_targets_met {
        println!(
            "✅ SUCCESS: All {} categories meet sub-{}μs target!",
            results.len(),
            target_us
        );
        println!("🚀 Trading Service is ready for production deployment!");
    } else {
        println!(
            "❌ PARTIAL: {}/{} categories meet sub-{}μs target",
            passed_categories,
            results.len(),
            target_us
        );
        println!("🔧 Optimization needed for failed categories");
    }

    println!();
    println!("📋 SYSTEM VALIDATION COMPLETE");
    println!("==============================");
    println!("This demo validates that the hdrhistogram-based latency");
    println!("recording system can accurately measure and report P50/P95/P99");
    println!("latencies for critical trading operations at sub-50μs precision.");
    println!();
    println!("The actual Trading Service implementation includes:");
    println!("  • TimingGuard for automatic RAII-based measurement");
    println!("  • Comprehensive soak testing with configurable load");
    println!("  • Integration with all critical trading paths");
    println!("  • Production-ready latency validation tooling");
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_latency_recording() {
        let recorder = DemoLatencyRecorder::new();

        // Record test latencies
        recorder.record(LatencyCategory::OrderSubmission, 25_000); // 25μs
        recorder.record(LatencyCategory::OrderSubmission, 35_000); // 35μs
        recorder.record(LatencyCategory::OrderSubmission, 45_000); // 45μs

        let stats = recorder
            .get_stats(LatencyCategory::OrderSubmission)
            .unwrap();
        assert_eq!(stats.count, 3);
        assert!(stats.meets_target(50.0));
        assert!(stats.p99_us() < 50.0);
    }

    #[test]
    fn test_cpu_work_simulation() {
        let start = Instant::now();
        simulate_cpu_work(Duration::from_micros(10));
        let elapsed = start.elapsed();

        // Should take at least the requested time
        assert!(elapsed >= Duration::from_micros(8));
        assert!(elapsed < Duration::from_micros(50));
    }
}