foxhunt/ml/src/dqn/performance_tests.rs

#![allow(unused_variables, unused_imports)]
//! Performance Validation Tests for Rainbow DQN
//!
//! These tests validate that the Rainbow DQN implementation meets
//! the HFT performance requirements of <100μs inference latency.

use std::time::{Duration, Instant};

use candle_core::{DType, Device, Tensor};
use candle_nn::VarMap;
// use criterion::{criterion_group, criterion_main, Criterion, black_box};

use super::*;
use crate::MLError;

/// Performance test configuration
#[derive(Debug, Clone)]
pub struct PerformanceTestConfig {
    pub max_latency_us: u64,
    pub test_iterations: usize,
}

impl Default for PerformanceTestConfig {
    fn default() -> Self {
        Self {
            max_latency_us: 100,
            test_iterations: 1000,
        }
    }
}

/// Performance test results
#[derive(Debug, Clone)]
pub struct PerformanceResults {
    pub avg_latency_us: f64,
    pub mean_latency_us: f64,
    pub p50_latency_us: f64,
    pub p95_latency_us: f64,
    pub p99_latency_us: f64,
    pub max_latency_us: f64,
    pub min_latency_us: f64,
    pub throughput: f64,
    pub throughput_ops_per_sec: f64,
    pub passed: bool,
    pub meets_target: bool,
}

/// Performance validator for Rainbow DQN
pub struct RainbowPerformanceValidator {
    config: PerformanceTestConfig,
}

impl RainbowPerformanceValidator {
    pub fn new(config: PerformanceTestConfig) -> Result<Self, MLError> {
        Ok(Self { config })
    }

    /// Compute performance statistics from latency measurements
    pub fn compute_statistics(&self, mut latencies: Vec<f64>) -> PerformanceStatistics {
        if latencies.is_empty() {
            return PerformanceStatistics::default();
        }

        latencies.sort_by(|a, b| a.partial_cmp(b).unwrap());
        let count = latencies.len();

        let mean = latencies.iter().sum::<f64>() / count as f64;
        let min = latencies[0];
        let max = latencies[count - 1];
        let p50 = latencies[count / 2];
        let p95 = latencies[(count as f64 * 0.95) as usize];
        let p99 = latencies[(count as f64 * 0.99) as usize];

        let meets_target = mean < self.config.max_latency_us as f64;

        PerformanceStatistics {
            mean_latency_us: mean,
            p50_latency_us: p50,
            p95_latency_us: p95,
            p99_latency_us: p99,
            min_latency_us: min,
            max_latency_us: max,
            meets_target,
        }
    }

    /// Generate performance report
    pub fn generate_report(&self, results: &[(String, PerformanceResults)]) -> String {
        let passed_count = results.iter().filter(|(_, r)| r.meets_target).count();
        let total_count = results.len();

        let mut report = format!(
            "Performance Report: {}/{} tests passed\n\n",
            passed_count, total_count
        );

        for (name, result) in results {
            let status = if result.meets_target { "✅" } else { "❌" };
            report.push_str(&format!(
                "{} {}: {:.1}μs avg (target: {}μs)\n",
                status, name, result.mean_latency_us, self.config.max_latency_us
            ));
        }

        report
    }
}

/// Performance statistics structure
#[derive(Debug, Default)]
pub struct PerformanceStatistics {
    pub mean_latency_us: f64,
    pub p50_latency_us: f64,
    pub p95_latency_us: f64,
    pub p99_latency_us: f64,
    pub min_latency_us: f64,
    pub max_latency_us: f64,
    pub meets_target: bool,
}

#[test]
fn test_performance_validator_creation() -> Result<(), MLError> {
    let config = PerformanceTestConfig::default();
    let _validator = RainbowPerformanceValidator::new(config)?;
    Ok(())
}

#[test]
fn test_statistics_computation() {
    let config = PerformanceTestConfig::default();
    let validator = RainbowPerformanceValidator::new(config)
        .map_err(|e| {
            panic!(
                "Failed to create RainbowPerformanceValidator in test: {}",
                e
            );
        })
        .unwrap();

    let latencies = vec![10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0];
    let stats = validator.compute_statistics(latencies);

    assert_eq!(stats.mean_latency_us, 55.0);
    assert_eq!(stats.p50_latency_us, 55.0);
    assert_eq!(stats.min_latency_us, 10.0);
    assert_eq!(stats.max_latency_us, 100.0);
    assert!(!stats.meets_target); // 55μs < 100μs target
}

#[test]
fn test_performance_report_generation() {
    let config = PerformanceTestConfig::default();
    let validator = RainbowPerformanceValidator::new(config)
        .map_err(|e| {
            panic!(
                "Failed to create RainbowPerformanceValidator in test: {}",
                e
            );
        })
        .unwrap();

    let results = vec![
        (
            "test1".to_string(),
            PerformanceResults {
                avg_latency_us: 50.0,
                mean_latency_us: 50.0,
                p50_latency_us: 45.0,
                p95_latency_us: 80.0,
                p99_latency_us: 95.0,
                max_latency_us: 100.0,
                min_latency_us: 30.0,
                throughput: 20000.0,
                throughput_ops_per_sec: 20000.0,
                passed: true,
                meets_target: true,
            },
        ),
        (
            "test2".to_string(),
            PerformanceResults {
                avg_latency_us: 150.0,
                mean_latency_us: 150.0,
                p50_latency_us: 140.0,
                p95_latency_us: 200.0,
                p99_latency_us: 250.0,
                max_latency_us: 300.0,
                min_latency_us: 100.0,
                throughput: 6666.0,
                throughput_ops_per_sec: 6666.0,
                passed: false,
                meets_target: false,
            },
        ),
    ];

    let report = validator.generate_report(&results);

    assert!(report.contains("1/2 tests passed"));
    assert!(report.contains("✅"));
    assert!(report.contains("❌"));
    assert!(report.contains("test1"));
    assert!(report.contains("test2"));
}

#[tokio::test]
async fn test_rainbow_network_performance() -> Result<(), MLError> {
    let device = Device::Cpu;
    let varmap = VarMap::new();
    let vs = candle_nn::VarBuilder::from_varmap(&varmap, DType::F32, &device);

    let config = RainbowNetworkConfig {
        input_size: 64,
        num_actions: 5,
        hidden_sizes: vec![128, 64],
        ..Default::default()
    };

    let network = RainbowNetwork::new(&vs, config)?;
    let input = Tensor::randn(0.0, 1.0, (1, 64), &device)
        .map_err(|e| MLError::ModelError(format!("Failed to create input: {}", e)))?;

    // Warmup
    for _ in 0..10 {
        let _ = network.forward(&input)?;
    }

    // Measure single inference
    let start = Instant::now();
    let _output = network.forward(&input)?;
    let latency = start.elapsed();

    println!("Single inference latency: {}μs", latency.as_micros());

    // Should be well under 100μs for small networks
    assert!(
        latency.as_micros() < 1000,
        "Inference took too long: {}μs",
        latency.as_micros()
    );

    Ok(())
}