foxhunt/common/benches/ml_strategy_bench.rs

//! Performance Benchmarks for 25-Feature ML Strategy System
//!
//! Agent A13 - Comprehensive latency and memory profiling for:
//! - Individual technical indicators (RSI, MACD, BB, ATR, Stochastic, ADX, CCI)
//! - Full 25-feature extraction end-to-end
//! - Memory usage analysis
//!
//! ## Targets
//! - Individual indicators: <5μs per update
//! - Full 25-feature extraction: <100μs per bar
//! - Memory: <500 bytes per symbol state
//!
//! ## Run Benchmarks
//! ```bash
//! cargo bench -p common --bench ml_strategy_bench
//! ```

use chrono::Utc;
use common::ml_strategy::MLFeatureExtractor;
use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
use std::time::Duration;

// ============================================================================
// Test Data Generator
// ============================================================================

/// Generate realistic market data for benchmarking
fn generate_market_data(num_bars: usize, seed: u64) -> Vec<(f64, f64)> {
    use std::f64::consts::PI;

    let mut rng = fastrand::Rng::with_seed(seed);
    let mut data = Vec::with_capacity(num_bars);
    let mut price = 100.0;

    for i in 0..num_bars {
        // Combine trend, cycle, and noise
        let trend = (i as f64 * 0.01) % 10.0 - 5.0;
        let cycle = (i as f64 * 0.1 * PI).sin() * 2.0;
        let noise = (rng.f64() - 0.5) * 0.5;

        price += trend * 0.01 + cycle * 0.05 + noise;
        price = price.max(50.0).min(150.0);

        let volume = 10000.0 + (i as f64 * 0.5 * PI).sin().abs() * 5000.0 + rng.f64() * 2000.0;

        data.push((price, volume));
    }

    data
}

// ============================================================================
// Individual Indicator Benchmarks
// ============================================================================

/// Benchmark RSI (14-period) incremental update
fn bench_rsi_update(c: &mut Criterion) {
    let mut group = c.benchmark_group("indicator_rsi");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 42);

    // Warm up extractor with 20 bars
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(20) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_update", |b| {
        let mut ext = extractor.clone();
        let mut idx = 20;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features[23]); // RSI is at index 23
        });
    });

    group.finish();
}

/// Benchmark MACD incremental update (EMA-12, EMA-26, Signal-9)
fn bench_macd_update(c: &mut Criterion) {
    let mut group = c.benchmark_group("indicator_macd");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 43);

    // Warm up extractor
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(26) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_update", |b| {
        let mut ext = extractor.clone();
        let mut idx = 26;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features[24]); // MACD line
            black_box(features[25]); // MACD signal
        });
    });

    group.finish();
}

/// Benchmark Bollinger Bands (20-period SMA + 2σ)
fn bench_bollinger_bands(c: &mut Criterion) {
    let mut group = c.benchmark_group("indicator_bollinger_bands");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 44);

    // Warm up with 20 bars
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(20) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_update", |b| {
        let mut ext = extractor.clone();
        let mut idx = 20;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features[19]); // BB position at index 19
        });
    });

    group.finish();
}

/// Benchmark Stochastic Oscillator (%K and %D)
fn bench_stochastic(c: &mut Criterion) {
    let mut group = c.benchmark_group("indicator_stochastic");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 45);

    // Warm up with 14 bars
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(14) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_update", |b| {
        let mut ext = extractor.clone();
        let mut idx = 14;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features[20]); // Stochastic %K
            black_box(features[21]); // Stochastic %D
        });
    });

    group.finish();
}

/// Benchmark ADX (Average Directional Index, 14-period)
fn bench_adx(c: &mut Criterion) {
    let mut group = c.benchmark_group("indicator_adx");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 46);

    // Warm up with 14 bars
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(14) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_update", |b| {
        let mut ext = extractor.clone();
        let mut idx = 14;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features[18]); // ADX at index 18
        });
    });

    group.finish();
}

/// Benchmark CCI (Commodity Channel Index, 20-period)
fn bench_cci(c: &mut Criterion) {
    let mut group = c.benchmark_group("indicator_cci");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 47);

    // Warm up with 20 bars
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(20) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_update", |b| {
        let mut ext = extractor.clone();
        let mut idx = 20;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features[22]); // CCI at index 22
        });
    });

    group.finish();
}

/// Benchmark ATR (Average True Range) - part of ADX calculation
fn bench_atr(c: &mut Criterion) {
    let mut group = c.benchmark_group("indicator_atr");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 48);

    // Warm up with 14 bars
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(14) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_update", |b| {
        let mut ext = extractor.clone();
        let mut idx = 14;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            // ATR is internal state, accessed via ADX feature
            black_box(features[18]); // ADX uses ATR internally
        });
    });

    group.finish();
}

// ============================================================================
// End-to-End Feature Extraction Benchmarks
// ============================================================================

/// Benchmark full 25-feature extraction (cold start)
fn bench_full_extraction_cold(c: &mut Criterion) {
    let mut group = c.benchmark_group("full_extraction_cold");
    group.measurement_time(Duration::from_secs(10));

    let data = generate_market_data(30, 50);

    group.bench_function("30_bars_cold_start", |b| {
        let timestamp = Utc::now();

        b.iter(|| {
            let mut extractor = MLFeatureExtractor::new(30);

            for (price, volume) in &data {
                let features =
                    extractor.extract_features(black_box(*price), black_box(*volume), timestamp);
                black_box(features);
            }
        });
    });

    group.finish();
}

/// Benchmark full 25-feature extraction (warm state, single update)
fn bench_full_extraction_warm(c: &mut Criterion) {
    let mut group = c.benchmark_group("full_extraction_warm");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(1000, 51);

    // Warm up extractor with 30 bars
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(30) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("single_bar_warm", |b| {
        let mut ext = extractor.clone();
        let mut idx = 30;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features);
        });
    });

    group.finish();
}

/// Benchmark throughput: bars processed per second
fn bench_extraction_throughput(c: &mut Criterion) {
    let mut group = c.benchmark_group("extraction_throughput");
    group.measurement_time(Duration::from_secs(10));

    for batch_size in [10, 100, 1000] {
        let data = generate_market_data(batch_size, 52);

        group.bench_with_input(
            BenchmarkId::from_parameter(batch_size),
            &batch_size,
            |b, _| {
                let timestamp = Utc::now();

                b.iter(|| {
                    let mut extractor = MLFeatureExtractor::new(30);

                    for (price, volume) in &data {
                        let features = extractor.extract_features(
                            black_box(*price),
                            black_box(*volume),
                            timestamp,
                        );
                        black_box(features);
                    }
                });
            },
        );
    }

    group.finish();
}

/// Benchmark feature extraction with different lookback windows
fn bench_lookback_impact(c: &mut Criterion) {
    let mut group = c.benchmark_group("lookback_window_impact");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(100, 53);

    for lookback in [20, 30, 50, 100] {
        group.bench_with_input(
            BenchmarkId::from_parameter(lookback),
            &lookback,
            |b, &lb| {
                let timestamp = Utc::now();

                b.iter(|| {
                    let mut extractor = MLFeatureExtractor::new(lb);

                    // Process all bars
                    for (price, volume) in &data {
                        let features = extractor.extract_features(
                            black_box(*price),
                            black_box(*volume),
                            timestamp,
                        );
                        black_box(features);
                    }
                });
            },
        );
    }

    group.finish();
}

// ============================================================================
// Memory Benchmarks
// ============================================================================

/// Memory usage analysis for MLFeatureExtractor
fn bench_memory_usage(c: &mut Criterion) {
    let mut group = c.benchmark_group("memory_usage");
    group.measurement_time(Duration::from_secs(3));

    group.bench_function("extractor_size", |b| {
        b.iter(|| {
            let extractor = MLFeatureExtractor::new(black_box(30));
            black_box(std::mem::size_of_val(&extractor));
        });
    });

    // Measure memory after warmup
    group.bench_function("extractor_warm_size", |b| {
        let data = generate_market_data(30, 54);
        let timestamp = Utc::now();

        b.iter(|| {
            let mut extractor = MLFeatureExtractor::new(30);

            // Fill with data
            for (price, volume) in &data {
                extractor.extract_features(*price, *volume, timestamp);
            }

            black_box(std::mem::size_of_val(&extractor));
        });
    });

    group.finish();
}

// ============================================================================
// Latency Distribution Analysis
// ============================================================================

/// Measure P50/P95/P99 latencies for feature extraction
fn bench_latency_distribution(c: &mut Criterion) {
    let mut group = c.benchmark_group("latency_distribution");
    group.measurement_time(Duration::from_secs(10));
    group.sample_size(1000); // Increase sample size for better percentile accuracy

    let data = generate_market_data(1000, 55);

    // Warm up extractor
    let mut extractor = MLFeatureExtractor::new(30);
    let timestamp = Utc::now();
    for (price, volume) in data.iter().take(30) {
        extractor.extract_features(*price, *volume, timestamp);
    }

    group.bench_function("p50_p95_p99_latency", |b| {
        let mut ext = extractor.clone();
        let mut idx = 30;

        b.iter(|| {
            let (price, volume) = data[idx % data.len()];
            let features = ext.extract_features(black_box(price), black_box(volume), timestamp);
            idx += 1;
            black_box(features);
        });
    });

    group.finish();
}

// ============================================================================
// Comparative Benchmarks
// ============================================================================

/// Compare feature extraction with/without oscillators
fn bench_oscillator_overhead(c: &mut Criterion) {
    let mut group = c.benchmark_group("oscillator_overhead");
    group.measurement_time(Duration::from_secs(5));

    let data = generate_market_data(100, 56);
    let timestamp = Utc::now();

    // Benchmark: Extract only first 7 base features (price, volume, time)
    group.bench_function("base_features_7", |b| {
        b.iter(|| {
            let mut extractor = MLFeatureExtractor::new(30);

            for (price, volume) in &data {
                let features =
                    extractor.extract_features(black_box(*price), black_box(*volume), timestamp);
                // Access only base features
                black_box(&features[0..7]);
            }
        });
    });

    // Benchmark: Full 26-feature extraction (7 base + 3 oscillators + 3 volume + 5 EMA + 8 new)
    group.bench_function("full_features_26", |b| {
        b.iter(|| {
            let mut extractor = MLFeatureExtractor::new(30);

            for (price, volume) in &data {
                let features =
                    extractor.extract_features(black_box(*price), black_box(*volume), timestamp);
                black_box(features);
            }
        });
    });

    group.finish();
}

// ============================================================================
// Criterion Configuration
// ============================================================================

criterion_group!(
    benches,
    // Individual indicators
    bench_rsi_update,
    bench_macd_update,
    bench_bollinger_bands,
    bench_stochastic,
    bench_adx,
    bench_cci,
    bench_atr,
    // End-to-end extraction
    bench_full_extraction_cold,
    bench_full_extraction_warm,
    bench_extraction_throughput,
    bench_lookback_impact,
    // Memory analysis
    bench_memory_usage,
    // Latency distribution
    bench_latency_distribution,
    // Comparative analysis
    bench_oscillator_overhead,
);

criterion_main!(benches);