optirs-tpu 0.3.1

use std::fmt::Debug;
// Configuration Types and Settings
//
// This module defines all configuration structures used throughout the XLA compilation system,
// including compiler configurations, runtime settings, and various optimization parameters.

use num_cpus;
use scirs2_core::numeric::Float;
use std::collections::HashMap;
use std::time::Duration;

use super::super::{TPUConfig, TPUVersion, XLAOptimizationLevel};
use super::types::{AttributeValue, ElementType, OperationId, OperationType};

/// XLA compiler configuration
#[derive(Debug, Clone)]
pub struct XLACompilerConfig {
    /// Target TPU configuration
    pub target_tpu: TPUConfig,

    /// Optimization level
    pub optimization_level: XLAOptimizationLevel,

    /// Enable auto-tuning
    pub enable_auto_tuning: bool,

    /// Compilation timeout (seconds)
    pub compilation_timeout: u64,

    /// Maximum cache size (MB)
    pub max_cache_size_mb: usize,

    /// Enable parallel compilation
    pub parallel_compilation: bool,

    /// Number of compilation threads
    pub compilation_threads: usize,

    /// Enable fusion optimization
    pub enable_fusion: bool,

    /// Enable layout optimization
    pub enable_layout_optimization: bool,

    /// Enable memory optimization
    pub enable_memory_optimization: bool,

    /// Enable pipeline optimization
    pub enable_pipeline_optimization: bool,

    /// Debug mode
    pub debug_mode: bool,

    /// Profile compilation
    pub profile_compilation: bool,

    /// Custom optimization passes
    pub custom_passes: Vec<String>,

    /// Enable advanced tensor core optimizations
    pub enable_tensor_core_optimization: bool,

    /// Enable sparsity-aware optimizations
    pub enable_sparsity_optimization: bool,

    /// Enable quantization-aware optimizations
    pub enable_quantization_optimization: bool,

    /// Enable gradient accumulation optimization
    pub enable_gradient_accumulation_optimization: bool,

    /// Advanced memory coalescing
    pub enable_advanced_memory_coalescing: bool,

    /// Dynamic shape optimization
    pub enable_dynamicshape_optimization: bool,

    /// Cross-replica optimization
    pub enable_cross_replica_optimization: bool,
}

impl Default for XLACompilerConfig {
    fn default() -> Self {
        Self {
            target_tpu: TPUConfig::default(),
            optimization_level: XLAOptimizationLevel::Standard,
            enable_auto_tuning: true,
            compilation_timeout: 300, // 5 minutes
            max_cache_size_mb: 1024,  // 1GB
            parallel_compilation: true,
            compilation_threads: num_cpus::get(),
            enable_fusion: true,
            enable_layout_optimization: true,
            enable_memory_optimization: true,
            enable_pipeline_optimization: true,
            debug_mode: false,
            profile_compilation: false,
            custom_passes: Vec::new(),
            enable_tensor_core_optimization: true,
            enable_sparsity_optimization: true,
            enable_quantization_optimization: true,
            enable_gradient_accumulation_optimization: true,
            enable_advanced_memory_coalescing: true,
            enable_dynamicshape_optimization: true,
            enable_cross_replica_optimization: true,
        }
    }
}

/// Runtime configuration
#[derive(Debug, Clone)]
pub struct RuntimeConfig {
    pub optimization_level: XLAOptimizationLevel,
    pub parallel_compilation: bool,
    pub memory_optimization: bool,
    pub debug_mode: bool,
}

/// Storage configuration
#[derive(Debug, Clone)]
pub struct StorageConfiguration {
    pub max_events: usize,
    pub compression_enabled: bool,
    pub persistence_enabled: bool,
    pub retention_policy: RetentionPolicy,
}

/// Retention policy
#[derive(Debug, Clone)]
pub enum RetentionPolicy {
    KeepAll,
    KeepLatest(usize),
    KeepByTime(Duration),
    KeepBySize(usize),
}

/// Tool configuration
#[derive(Debug, Clone)]
pub struct ToolConfiguration {
    pub parameters: HashMap<String, ConfigurationValue>,
    pub thresholds: HashMap<String, f64>,
    pub output_format: OutputFormat,
}

/// Configuration value
#[derive(Debug, Clone)]
pub enum ConfigurationValue {
    Boolean(bool),
    Integer(i64),
    Float(f64),
    String(String),
}

/// Output format
#[derive(Debug, Clone, Copy)]
pub enum OutputFormat {
    JSON,
    CSV,
    Binary,
    Text,
}

/// Work stealing configuration for parallel compilation
#[derive(Debug, Clone)]
pub struct WorkStealingConfig {
    pub enabled: bool,
    pub steal_threshold: f64,
    pub steal_ratio: f64,
    pub victim_selection: VictimSelection,
}

/// Victim selection strategies
#[derive(Debug, Clone, Copy)]
pub enum VictimSelection {
    Random,
    MostLoaded,
    LeastLoaded,
    Neighbor,
}

/// Prediction cache configuration
#[derive(Debug, Clone)]
pub struct PredictionCacheConfig {
    pub max_entries: usize,
    pub ttl: Duration,
    pub eviction_policy: CacheEvictionPolicy,
}

/// Cache eviction policy
#[derive(Debug, Clone, Copy)]
pub enum CacheEvictionPolicy {
    LRU,
    LFU,
    FIFO,
    Random,
    TTL,
}

/// Mixed precision configuration
#[derive(Debug, Clone)]
pub struct MixedPrecisionConfig {
    pub enabled: bool,
    pub precision_mapping: HashMap<OperationType, ElementType>,
    pub automatic_casting: bool,
    pub loss_scaling: bool,
    pub gradient_clipping: bool,
}

/// Dithering configuration
#[derive(Debug, Clone)]
pub struct DitheringConfig {
    pub enabled: bool,
    pub dither_type: DitherType,
    pub amplitude: f64,
}

/// Types of dithering
#[derive(Debug, Clone)]
pub enum DitherType {
    Triangular,
    Gaussian,
    Uniform,
    HighPass,
}

/// Noise shaping configuration
#[derive(Debug, Clone)]
pub struct NoiseShapingConfig {
    pub enabled: bool,
    pub filter_order: usize,
    pub cutoff_frequency: f64,
}

/// Adaptive quantization configuration
#[derive(Debug)]
pub struct AdaptiveQuantizationConfig<T: Float + Debug + Send + Sync + 'static> {
    pub enabled: bool,
    pub adaptation_rate: T,
    pub target_quality: f64,
    pub feedback_mechanism: FeedbackMechanism,
}

/// Feedback mechanisms for adaptive quantization
#[derive(Debug, Clone)]
pub enum FeedbackMechanism {
    ErrorBased,
    QualityBased,
    PerformanceBased,
    Hybrid,
}

/// Noise characteristics for quantization
#[derive(Debug, Clone)]
pub struct NoiseCharacteristics {
    pub distribution: NoiseDistribution,
    pub variance: f64,
    pub correlation: f64,
    pub time_varying: bool,
}

/// Distribution of quantization noise
#[derive(Debug, Clone)]
pub enum NoiseDistribution {
    Uniform,
    Gaussian,
    Laplacian,
    StudentT,
    Custom,
}

/// Models for noise propagation
#[derive(Debug, Clone)]
pub enum PropagationModel {
    Linear,
    Nonlinear,
    Statistical,
    MonteCarlo,
}

/// Planning algorithms for memory optimization
#[derive(Debug, Clone, Copy)]
pub enum PlanningAlgorithm {
    GreedyPlanning,
    OptimalPlanning,
    HeuristicPlanning,
    MachineLearningBased,
}

/// Allocation strategies for memory management
#[derive(Debug, Clone, Copy)]
pub enum AllocationStrategy {
    FirstFit,
    BestFit,
    WorstFit,
    NextFit,
    BuddySystem,
    PoolBased,
}

/// Profiling strategies
#[derive(Debug, Clone, Copy)]
pub enum ProfilingStrategy {
    SamplingBased,
    InstrumentationBased,
    HardwareCounters,
    SoftwareTracing,
    Hybrid,
}

/// Analysis tool types for profiling
#[derive(Debug, Clone, Copy)]
pub enum AnalysisToolType {
    TimelineAnalyzer,
    HotspotDetector,
    BottleneckAnalyzer,
    MemoryAnalyzer,
    CommunicationAnalyzer,
}

/// Block sparsity configuration
#[derive(Debug, Clone)]
pub struct BlockSparsityConfig {
    pub block_size: (usize, usize),
    pub sparsity_ratio: f64,
    pub pattern: SparsityPattern,
    pub structured: bool,
}

/// Sparsity patterns
#[derive(Debug, Clone, Copy)]
pub enum SparsityPattern {
    Random,
    Structured,
    NToM(usize, usize),
    Block,
    Magnitude,
}

/// Rewrite priority levels
#[derive(Debug, Clone, Copy)]
pub enum RewritePriority {
    Low,
    Medium,
    High,
    Critical,
}