optirs-core 0.3.1

// Cross-platform performance testing and benchmarking
//
// This module provides cross-platform performance testing capabilities
// for optimization algorithms across different hardware targets.

use std::collections::HashMap;
use std::fmt::Debug;
use std::time::{Duration, Instant};

// SciRS2 Integration - ESSENTIAL for benchmarking
#[cfg(feature = "cross-platform-testing")]
use scirs2_datasets;
use scirs2_stats::distributions;

use crate::error::{OptimError, Result};

/// Platform target for cross-platform testing
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PlatformTarget {
    /// CPU-based execution
    CPU,
    /// CUDA GPU
    CUDA,
    /// Metal GPU (macOS)
    Metal,
    /// OpenCL GPU
    OpenCL,
    /// WebGPU
    WebGPU,
    /// TPU
    TPU,
    /// Custom platform
    Custom(String),
}

/// Performance baseline for comparison
#[derive(Debug, Clone)]
pub struct PerformanceBaseline {
    pub target: PlatformTarget,
    pub throughput_ops_per_sec: f64,
    pub latency_ms: f64,
    pub memory_usage_mb: f64,
    pub energy_consumption_joules: Option<f64>,
    pub accuracy_metrics: HashMap<String, f64>,
}

impl PerformanceBaseline {
    pub fn new(target: PlatformTarget) -> Self {
        Self {
            target,
            throughput_ops_per_sec: 0.0,
            latency_ms: 0.0,
            memory_usage_mb: 0.0,
            energy_consumption_joules: None,
            accuracy_metrics: HashMap::new(),
        }
    }

    pub fn with_throughput(mut self, ops_per_sec: f64) -> Self {
        self.throughput_ops_per_sec = ops_per_sec;
        self
    }

    pub fn with_latency(mut self, latency_ms: f64) -> Self {
        self.latency_ms = latency_ms;
        self
    }

    pub fn with_memory_usage(mut self, memory_mb: f64) -> Self {
        self.memory_usage_mb = memory_mb;
        self
    }
}

/// Cross-platform performance tester
#[derive(Debug)]
pub struct CrossPlatformTester {
    baselines: HashMap<PlatformTarget, PerformanceBaseline>,
    test_configurations: HashMap<String, TestConfiguration>,
}

/// Test configuration for benchmarking
#[derive(Debug, Clone)]
pub struct TestConfiguration {
    pub name: String,
    pub iterations: usize,
    pub warmup_iterations: usize,
    pub data_size: usize,
    pub timeout: Duration,
}

impl CrossPlatformTester {
    pub fn new() -> Self {
        Self {
            baselines: HashMap::new(),
            test_configurations: HashMap::new(),
        }
    }

    pub fn add_baseline(&mut self, baseline: PerformanceBaseline) {
        self.baselines.insert(baseline.target.clone(), baseline);
    }

    pub fn add_test_config(&mut self, config: TestConfiguration) {
        self.test_configurations.insert(config.name.clone(), config);
    }

    pub fn run_benchmark(
        &self,
        target: &PlatformTarget,
        test_name: &str,
    ) -> Result<PerformanceBaseline> {
        let config = self.test_configurations.get(test_name).ok_or_else(|| {
            OptimError::InvalidConfig(format!("Test configuration '{}' not found", test_name))
        })?;

        // Run benchmark (simplified implementation)
        let start = Instant::now();

        // Simulate benchmark execution
        std::thread::sleep(Duration::from_millis(1));

        let duration = start.elapsed();
        let throughput = config.iterations as f64 / duration.as_secs_f64();

        Ok(PerformanceBaseline::new(target.clone())
            .with_throughput(throughput)
            .with_latency(duration.as_millis() as f64 / config.iterations as f64))
    }

    pub fn compare_performance(
        &self,
        target1: &PlatformTarget,
        target2: &PlatformTarget,
    ) -> Result<f64> {
        let baseline1 = self.baselines.get(target1).ok_or_else(|| {
            OptimError::InvalidConfig("Baseline for target1 not found".to_string())
        })?;
        let baseline2 = self.baselines.get(target2).ok_or_else(|| {
            OptimError::InvalidConfig("Baseline for target2 not found".to_string())
        })?;

        Ok(baseline1.throughput_ops_per_sec / baseline2.throughput_ops_per_sec)
    }
}

impl Default for CrossPlatformTester {
    fn default() -> Self {
        Self::new()
    }
}