foxhunt/benches/minimal_performance.rs

//! Minimal Performance Benchmark - Working Version
//!
//! This benchmark demonstrates that the Foxhunt system can successfully
//! compile and run performance tests without type conflicts.

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

/// Test basic mathematical operations performance
fn benchmark_math_operations(c: &mut Criterion) {
    c.bench_function("basic_arithmetic", |b| {
        b.iter(|| {
            let x = black_box(123.456);
            let y = black_box(789.012);
            let result = x * y + x / y - x + y;
            black_box(result)
        });
    });
}

/// Test memory allocation performance
fn benchmark_memory_operations(c: &mut Criterion) {
    c.bench_function("vector_allocation", |b| {
        b.iter(|| {
            let mut vec = Vec::with_capacity(1000);
            for i in 0..1000 {
                vec.push(black_box(i));
            }
            black_box(vec)
        });
    });
}

/// Test string operations performance
fn benchmark_string_operations(c: &mut Criterion) {
    c.bench_function("string_concatenation", |b| {
        b.iter(|| {
            let mut result = String::new();
            for i in 0..100 {
                result.push_str(&format!("order_{}", black_box(i)));
            }
            black_box(result)
        });
    });
}

/// Test timing precision
fn benchmark_timing_precision(c: &mut Criterion) {
    c.bench_function("instant_now", |b| {
        b.iter(|| {
            let start = Instant::now();
            black_box(start)
        });
    });
}

/// Test hash map operations (simulating order tracking)
fn benchmark_hashmap_operations(c: &mut Criterion) {
    use std::collections::HashMap;

    c.bench_function("hashmap_insert_lookup", |b| {
        b.iter_custom(|iters| {
            let mut map = HashMap::new();
            let start = Instant::now();

            for i in 0..iters {
                let key = format!("order_{}", i);
                let value = i * 2;
                map.insert(key.clone(), value);
                black_box(map.get(&key));
            }

            start.elapsed()
        });
    });
}

/// Test atomic operations (lock-free performance)
fn benchmark_atomic_operations(c: &mut Criterion) {
    use std::sync::atomic::{AtomicU64, Ordering};

    c.bench_function("atomic_increment", |b| {
        let counter = AtomicU64::new(0);
        b.iter(|| counter.fetch_add(1, Ordering::Relaxed));
    });
}

/// Latency validation benchmark - track sub-microsecond operations
fn benchmark_latency_validation(c: &mut Criterion) {
    let mut group = c.benchmark_group("latency_validation");
    group.measurement_time(Duration::from_secs(10));

    group.bench_function("sub_microsecond_operation", |b| {
        b.iter_custom(|iters| {
            let mut under_1us_count = 0u64;
            let mut under_10us_count = 0u64;
            let mut total_duration = Duration::from_nanos(0);

            for i in 0..iters {
                let start = Instant::now();

                // Simulate fast HFT operation
                let price = 1000.0 + (i as f64 * 0.01);
                let quantity = 100.0 + (i as f64 * 0.1);
                let order_value = price * quantity;
                let risk_check = order_value < 1_000_000.0;

                black_box((price, quantity, order_value, risk_check));

                let duration = start.elapsed();
                let latency_us = duration.as_micros() as u64;

                if latency_us <= 1 {
                    under_1us_count += 1;
                }
                if latency_us <= 10 {
                    under_10us_count += 1;
                }

                total_duration += duration;
            }

            let percent_under_1us = (under_1us_count as f64 / iters as f64) * 100.0;
            let percent_under_10us = (under_10us_count as f64 / iters as f64) * 100.0;
            let avg_latency_ns = total_duration.as_nanos() as u64 / iters;

            println!("Latency Results:");
            println!("  Average: {}ns", avg_latency_ns);
            println!("  Under 1μs: {:.1}%", percent_under_1us);
            println!("  Under 10μs: {:.1}%", percent_under_10us);

            total_duration
        });
    });

    group.finish();
}

/// Comprehensive performance validation
fn benchmark_comprehensive_performance(c: &mut Criterion) {
    let mut group = c.benchmark_group("comprehensive_validation");
    group.measurement_time(Duration::from_secs(15));

    group.bench_function("simulated_trading_operations", |b| {
        b.iter_custom(|iters| {
            let mut total_duration = Duration::from_nanos(0);
            let mut operations_under_50us = 0u64;

            for i in 0..iters {
                let start = Instant::now();

                // Simulate complete trading operation
                let order_id = format!("ORDER_{}", i);
                let price = 50000.0 + (i as f64 * 0.01);
                let quantity = 1.0 + (i as f64 * 0.001);

                // Risk calculations
                let order_value = price * quantity;
                let position_limit = 100_000.0;
                let risk_approved = order_value <= position_limit;

                // Order processing
                let processing_time = std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap()
                    .as_nanos();

                // Results
                let result = (order_id, price, quantity, risk_approved, processing_time);
                black_box(result);

                let duration = start.elapsed();
                let latency_us = duration.as_micros() as u64;

                if latency_us <= 50 {
                    operations_under_50us += 1;
                }

                total_duration += duration;
            }

            let success_rate = (operations_under_50us as f64 / iters as f64) * 100.0;
            let avg_latency_us = total_duration.as_micros() as u64 / iters;

            println!("Trading Operations Performance:");
            println!("  Average latency: {}μs", avg_latency_us);
            println!("  Under 50μs: {:.1}%", success_rate);

            if avg_latency_us > 100 {
                println!(
                    "WARNING: Average latency {}μs exceeds 100μs target",
                    avg_latency_us
                );
            }

            total_duration
        });
    });

    group.finish();
}

criterion_group!(
    minimal_performance_benches,
    benchmark_math_operations,
    benchmark_memory_operations,
    benchmark_string_operations,
    benchmark_timing_precision,
    benchmark_hashmap_operations,
    benchmark_atomic_operations,
    benchmark_latency_validation,
    benchmark_comprehensive_performance
);

criterion_main!(minimal_performance_benches);