foxhunt/benches/core_performance_validation.rs

//! Core Performance Validation for Foxhunt HFT System
//!
//! This benchmark validates the core performance infrastructure without
//! dependencies on the broken workspace services.

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
use std::time::{Duration, Instant};

// Import only the working core modules
use trading_engine::lockfree::{message_types, HftMessage, LockFreeRingBuffer};
use trading_engine::simd::{AlignedPrices, AlignedVolumes, SafeSimdDispatcher, SimdLevel};
use trading_engine::timing::{calibrate_tsc, HardwareTimestamp, LatencyMeasurement};

/// Validate the 14ns RDTSC timing claim
fn benchmark_rdtsc_precision(c: &mut Criterion) {
    let mut group = c.benchmark_group("RDTSC Precision Validation");

    // Try to calibrate TSC
    match calibrate_tsc() {
        Ok(freq) => {
            println!("TSC calibrated: {} Hz", freq);
        }
        Err(e) => {
            println!("Warning: TSC calibration failed: {}", e);
        }
    }

    group.bench_function("single_timestamp_capture", |b| {
        b.iter(|| {
            let ts = HardwareTimestamp::now();
            black_box(ts);
        });
    });

    group.bench_function("timestamp_pair_latency", |b| {
        b.iter(|| {
            let ts1 = HardwareTimestamp::now();
            let ts2 = HardwareTimestamp::now();
            let latency = ts2.latency_ns(&ts1);
            black_box(latency);
        });
    });

    // Test measurement overhead
    group.bench_function("latency_measurement_overhead", |b| {
        b.iter(|| {
            let mut measurement = LatencyMeasurement::start();
            let latency = measurement.finish();
            black_box(latency);
        });
    });

    // Validate actual timing precision
    group.bench_function("timing_precision_validation", |b| {
        b.iter(|| {
            let measurements: Vec<u64> = (0..10)
                .map(|_| {
                    let ts1 = HardwareTimestamp::now();
                    let ts2 = HardwareTimestamp::now();
                    ts2.latency_ns(&ts1)
                })
                .collect();

            let min_latency = measurements.iter().min().copied().unwrap_or(0);
            let avg_latency = measurements.iter().sum::<u64>() / measurements.len() as u64;

            black_box((min_latency, avg_latency));
        });
    });

    group.finish();
}

/// Validate SIMD/AVX2 performance claims
fn benchmark_simd_performance(c: &mut Criterion) {
    let mut group = c.benchmark_group("SIMD Performance Validation");

    let dispatcher = SafeSimdDispatcher::new();
    println!("Detected SIMD Level: {}", dispatcher.simd_level());

    // Test data for benchmarks
    let prices: Vec<f64> = (0..1000).map(|i| 100.0 + (i as f64 * 0.01)).collect();
    let volumes: Vec<f64> = (0..1000).map(|i| 1000.0 + i as f64).collect();

    // Test different data sizes
    for &size in &[100, 500, 1000] {
        let test_prices = &prices[..size];
        let test_volumes = &volumes[..size];

        // VWAP calculation benchmark
        group.bench_with_input(BenchmarkId::new("vwap_adaptive", size), &size, |b, _| {
            let adaptive_ops = dispatcher.create_adaptive_price_ops();
            b.iter(|| {
                let vwap = adaptive_ops.calculate_vwap(test_prices, test_volumes);
                black_box(vwap);
            });
        });

        // Compare with scalar implementation
        group.bench_with_input(BenchmarkId::new("vwap_scalar", size), &size, |b, _| {
            b.iter(|| {
                let total_pv: f64 = test_prices
                    .iter()
                    .zip(test_volumes.iter())
                    .map(|(p, v)| p * v)
                    .sum();
                let total_volume: f64 = test_volumes.iter().sum();
                let vwap = if total_volume > 0.0 {
                    total_pv / total_volume
                } else {
                    0.0
                };
                black_box(vwap);
            });
        });

        // Test with aligned memory if AVX2 is available
        if dispatcher.simd_level() >= SimdLevel::AVX2 {
            let aligned_prices = AlignedPrices::from_slice(test_prices);
            let aligned_volumes = AlignedVolumes::from_slice(test_volumes);

            group.bench_with_input(
                BenchmarkId::new("vwap_aligned_avx2", size),
                &size,
                |b, _| {
                    if let Ok(price_ops) = dispatcher.create_price_ops() {
                        b.iter(|| unsafe {
                            let vwap =
                                price_ops.calculate_vwap_aligned(&aligned_prices, &aligned_volumes);
                            black_box(vwap);
                        });
                    }
                },
            );
        }
    }

    group.finish();
}

/// Validate lock-free data structure performance
fn benchmark_lockfree_performance(c: &mut Criterion) {
    let mut group = c.benchmark_group("Lock-Free Performance Validation");

    // Test different buffer sizes
    for &size in &[256, 1024, 4096] {
        match LockFreeRingBuffer::<HftMessage>::new(size) {
            Ok(buffer) => {
                let message =
                    HftMessage::new(message_types::ORDER_REQUEST, [1, 2, 3, 4, 5, 6, 7, 8]);

                group.bench_with_input(BenchmarkId::new("ringbuffer_push", size), &size, |b, _| {
                    b.iter(|| {
                        let result = buffer.try_push(message);
                        black_box(result);
                    });
                });

                // Pre-fill buffer for pop tests
                let _ = buffer.try_push(message);

                group.bench_with_input(BenchmarkId::new("ringbuffer_pop", size), &size, |b, _| {
                    b.iter(|| {
                        let result = buffer.try_pop();
                        black_box(result);
                        // Refill for next iteration
                        let _ = buffer.try_push(message);
                    });
                });

                group.bench_with_input(
                    BenchmarkId::new("ringbuffer_roundtrip", size),
                    &size,
                    |b, _| {
                        b.iter(|| {
                            let start = Instant::now();
                            let _ = buffer.try_push(message);
                            let _ = buffer.try_pop();
                            let elapsed = start.elapsed();
                            black_box(elapsed);
                        });
                    },
                );
            }
            Err(e) => {
                println!("Failed to create ring buffer of size {}: {}", size, e);
            }
        }
    }

    group.finish();
}

/// Validate sub-50μs end-to-end latency claims
fn benchmark_end_to_end_latency(c: &mut Criterion) {
    let mut group = c.benchmark_group("End-to-End Latency Validation");

    let dispatcher = SafeSimdDispatcher::new();
    let buffer = match LockFreeRingBuffer::<HftMessage>::new(1024) {
        Ok(buf) => buf,
        Err(e) => {
            println!("Failed to create buffer for end-to-end test: {}", e);
            return;
        }
    };

    // Sample market data
    let prices = vec![100.0, 100.1, 99.9, 100.2, 100.05];
    let volumes = vec![1000.0, 1500.0, 800.0, 2000.0, 1200.0];

    group.bench_function("hft_pipeline_simulation", |b| {
        b.iter(|| {
            let pipeline_start = HardwareTimestamp::now();

            // 1. Market data processing (VWAP calculation)
            let adaptive_ops = dispatcher.create_adaptive_price_ops();
            let _vwap = adaptive_ops.calculate_vwap(&prices, &volumes);

            // 2. Risk validation (simulated with timing)
            let risk_start = HardwareTimestamp::now();
            // Simulate risk calculation work
            for _ in 0..10 {
                black_box(std::hint::black_box(42));
            }
            let risk_end = HardwareTimestamp::now();
            let _risk_latency = risk_end.latency_ns(&risk_start);

            // 3. Order routing through lock-free buffer
            let message = HftMessage::new(message_types::ORDER_REQUEST, [1, 2, 3, 4, 5, 6, 7, 8]);
            let _ = buffer.try_push(message);
            let _ = buffer.try_pop();

            // 4. Execution simulation
            let exec_start = HardwareTimestamp::now();
            // Simulate execution work
            for _ in 0..20 {
                black_box(std::hint::black_box(42));
            }
            let exec_end = HardwareTimestamp::now();
            let _exec_latency = exec_end.latency_ns(&exec_start);

            let pipeline_end = HardwareTimestamp::now();
            let total_latency = pipeline_end.latency_ns(&pipeline_start);

            black_box(total_latency);
        });
    });

    group.bench_function("minimal_trading_path", |b| {
        b.iter(|| {
            let start = HardwareTimestamp::now();

            // Minimal path: timestamp -> calculation -> buffer -> timestamp
            let adaptive_ops = dispatcher.create_adaptive_price_ops();
            let _vwap = adaptive_ops.calculate_vwap(&prices[..2], &volumes[..2]);

            let message = HftMessage::new(message_types::HEARTBEAT, [1, 2, 3, 4, 5, 6, 7, 8]);
            let _ = buffer.try_push(message);
            let _ = buffer.try_pop();

            let end = HardwareTimestamp::now();
            let latency = end.latency_ns(&start);

            black_box(latency);
        });
    });

    group.finish();
}

/// Performance claims validation with specific targets
fn benchmark_performance_targets(c: &mut Criterion) {
    let mut group = c.benchmark_group("Performance Target Validation");

    // 14ns RDTSC timing target
    group.bench_function("rdtsc_14ns_target", |b| {
        b.iter(|| {
            let start = Instant::now();
            let _ts = HardwareTimestamp::now();
            let elapsed = start.elapsed().as_nanos();

            // Target: < 14ns for timestamp capture
            if elapsed > 14 {
                black_box(format!(
                    "Warning: Timestamp took {}ns > 14ns target",
                    elapsed
                ));
            }

            black_box(elapsed);
        });
    });

    // Sub-microsecond lock-free operations target
    group.bench_function("lockfree_1us_target", |b| {
        let buffer = LockFreeRingBuffer::<u64>::new(1024).expect("Buffer creation failed");

        b.iter(|| {
            let start = Instant::now();
            let _ = buffer.try_push(42);
            let _ = buffer.try_pop();
            let elapsed = start.elapsed().as_nanos();

            // Target: < 1000ns (1μs) for roundtrip
            if elapsed > 1000 {
                black_box(format!(
                    "Warning: Lock-free roundtrip took {}ns > 1000ns target",
                    elapsed
                ));
            }

            black_box(elapsed);
        });
    });

    // SIMD speedup target (should be >2x faster than scalar)
    group.bench_function("simd_2x_speedup_target", |b| {
        let dispatcher = SafeSimdDispatcher::new();
        let prices = vec![100.0; 100];
        let volumes = vec![1000.0; 100];

        b.iter(|| {
            // SIMD calculation
            let simd_start = Instant::now();
            let adaptive_ops = dispatcher.create_adaptive_price_ops();
            let _simd_vwap = adaptive_ops.calculate_vwap(&prices, &volumes);
            let simd_time = simd_start.elapsed().as_nanos();

            // Scalar calculation
            let scalar_start = Instant::now();
            let total_pv: f64 = prices.iter().zip(volumes.iter()).map(|(p, v)| p * v).sum();
            let total_volume: f64 = volumes.iter().sum();
            let _scalar_vwap = if total_volume > 0.0 {
                total_pv / total_volume
            } else {
                0.0
            };
            let scalar_time = scalar_start.elapsed().as_nanos();

            let speedup = scalar_time as f64 / simd_time as f64;

            // Target: >2x speedup for SIMD
            if speedup < 2.0 && dispatcher.simd_level() >= SimdLevel::AVX2 {
                black_box(format!(
                    "Warning: SIMD speedup {:.2}x < 2.0x target",
                    speedup
                ));
            }

            black_box((simd_time, scalar_time, speedup));
        });
    });

    group.finish();
}

criterion_group!(
    benches,
    benchmark_rdtsc_precision,
    benchmark_simd_performance,
    benchmark_lockfree_performance,
    benchmark_end_to_end_latency,
    benchmark_performance_targets
);
criterion_main!(benches);