tenflowers-core 0.1.1

//! Large Model Optimization Module
//!
//! This module provides optimizations for handling models with 1B+ parameters,
//! focusing on memory efficiency, gradient checkpointing, and model parallelism.

use crate::memory::{global_monitor_arc, PerformanceMonitor};
use crate::{DType, Device, Result, TensorError};
use std::collections::HashMap;
use std::sync::{Arc, Mutex, RwLock};
use std::time::Instant;

#[cfg(feature = "serialize")]
use serde::{Deserialize, Serialize};

/// Configuration for large model optimization
#[derive(Debug, Clone)]
pub struct LargeModelConfig {
    /// Enable gradient checkpointing to save memory
    pub enable_gradient_checkpointing: bool,
    /// Enable model parallelism across devices
    pub enable_model_parallelism: bool,
    /// Enable parameter offloading to CPU memory
    pub enable_parameter_offloading: bool,
    /// Enable mixed precision training
    pub enable_mixed_precision: bool,
    /// Maximum memory usage per device (MB)
    pub max_memory_per_device_mb: usize,
    /// Checkpoint granularity (number of layers between checkpoints)
    pub checkpoint_granularity: usize,
    /// Number of devices for model parallelism
    pub num_devices: usize,
    /// Enable dynamic memory management
    pub enable_dynamic_memory: bool,
    /// Enable tensor fusion for large operations
    pub enable_tensor_fusion: bool,
}

impl Default for LargeModelConfig {
    fn default() -> Self {
        Self {
            enable_gradient_checkpointing: true,
            enable_model_parallelism: true,
            enable_parameter_offloading: true,
            enable_mixed_precision: true,
            max_memory_per_device_mb: 16 * 1024, // 16GB
            checkpoint_granularity: 4,           // Checkpoint every 4 layers
            num_devices: 1,
            enable_dynamic_memory: true,
            enable_tensor_fusion: true,
        }
    }
}

/// Model partition information for parallelism
#[derive(Debug, Clone)]
pub struct ModelPartition {
    pub device: Device,
    pub layer_range: (usize, usize), // Start and end layer indices
    pub parameter_count: usize,
    pub memory_usage_mb: f64,
}

/// Gradient checkpoint for memory-efficient training
#[derive(Debug)]
pub struct GradientCheckpoint {
    pub layer_index: usize,
    pub activations: Vec<Box<dyn std::any::Any + Send + Sync>>, // Stored activations
    pub timestamp: Instant,
    pub memory_usage_mb: f64,
}

/// Memory optimization statistics
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub struct MemoryOptimizationStats {
    pub total_parameters: usize,
    pub memory_saved_by_checkpointing_mb: f64,
    pub memory_saved_by_offloading_mb: f64,
    pub memory_saved_by_mixed_precision_mb: f64,
    pub peak_memory_usage_mb: f64,
    pub memory_efficiency: f64, // Ratio of theoretical minimum to actual usage
    pub parallelism_overhead_mb: f64,
}

/// Large model optimization manager
#[allow(dead_code)]
pub struct LargeModelOptimizer {
    config: LargeModelConfig,
    partitions: RwLock<Vec<ModelPartition>>,
    checkpoints: RwLock<HashMap<usize, GradientCheckpoint>>,
    monitor: Arc<PerformanceMonitor>,
    offloaded_parameters: RwLock<HashMap<String, OffloadedParameter>>,
    stats: Mutex<MemoryOptimizationStats>,
}

/// Offloaded parameter information
#[derive(Debug)]
#[allow(dead_code)]
struct OffloadedParameter {
    name: String,
    shape: Vec<usize>,
    dtype: DType,
    cpu_storage: Vec<u8>, // Raw bytes stored on CPU
    last_accessed: Instant,
    access_count: usize,
}

impl LargeModelOptimizer {
    /// Create a new large model optimizer
    pub fn new(config: LargeModelConfig) -> Self {
        let stats = MemoryOptimizationStats {
            total_parameters: 0,
            memory_saved_by_checkpointing_mb: 0.0,
            memory_saved_by_offloading_mb: 0.0,
            memory_saved_by_mixed_precision_mb: 0.0,
            peak_memory_usage_mb: 0.0,
            memory_efficiency: 1.0,
            parallelism_overhead_mb: 0.0,
        };

        Self {
            config,
            partitions: RwLock::new(Vec::new()),
            checkpoints: RwLock::new(HashMap::new()),
            monitor: global_monitor_arc(),
            offloaded_parameters: RwLock::new(HashMap::new()),
            stats: Mutex::new(stats),
        }
    }

    /// Analyze model and create memory-optimized execution plan
    pub fn analyze_model(
        &self,
        total_layers: usize,
        parameters_per_layer: usize,
    ) -> Result<ModelExecutionPlan> {
        let total_parameters = total_layers * parameters_per_layer;

        // Update stats
        {
            let mut stats = self.stats.lock().expect("lock should not be poisoned");
            stats.total_parameters = total_parameters;
        }

        // Create model partitions for parallelism
        let partitions = if self.config.enable_model_parallelism && self.config.num_devices > 1 {
            self.create_model_partitions(total_layers, parameters_per_layer)?
        } else {
            vec![ModelPartition {
                device: Device::Cpu,
                layer_range: (0, total_layers),
                parameter_count: total_parameters,
                memory_usage_mb: self.estimate_memory_usage(total_parameters),
            }]
        };

        // Determine checkpoint points
        let checkpoint_points = if self.config.enable_gradient_checkpointing {
            (0..total_layers)
                .step_by(self.config.checkpoint_granularity)
                .collect()
        } else {
            Vec::new()
        };

        // Calculate memory savings
        let memory_savings = self.calculate_memory_savings(total_parameters, &checkpoint_points);

        let plan = ModelExecutionPlan {
            partitions: partitions.clone(),
            checkpoint_points,
            memory_savings,
            estimated_peak_memory_mb: self.estimate_peak_memory(&partitions),
            recommended_batch_size: self.recommend_batch_size(total_parameters),
            optimization_recommendations: self
                .generate_optimization_recommendations(total_parameters),
        };

        // Store partitions
        *self
            .partitions
            .write()
            .expect("write lock should not be poisoned") = partitions;

        Ok(plan)
    }

    /// Create model partitions for parallelism
    fn create_model_partitions(
        &self,
        total_layers: usize,
        parameters_per_layer: usize,
    ) -> Result<Vec<ModelPartition>> {
        let mut partitions = Vec::new();
        let layers_per_device = total_layers / self.config.num_devices;
        let remaining_layers = total_layers % self.config.num_devices;

        for device_id in 0..self.config.num_devices {
            let start_layer = device_id * layers_per_device;
            let mut end_layer = start_layer + layers_per_device;

            // Distribute remaining layers
            if device_id < remaining_layers {
                end_layer += 1;
            }

            let layer_count = end_layer - start_layer;
            let parameter_count = layer_count * parameters_per_layer;
            let memory_usage = self.estimate_memory_usage(parameter_count);

            // Check if memory usage exceeds device limit
            if memory_usage > self.config.max_memory_per_device_mb as f64 {
                return Err(TensorError::allocation_error_simple(format!(
                    "Device {} would require {:.1}MB, exceeding limit of {}MB",
                    device_id, memory_usage, self.config.max_memory_per_device_mb
                )));
            }

            let device = if device_id == 0 {
                Device::Cpu
            } else {
                #[cfg(feature = "gpu")]
                {
                    Device::Gpu(device_id - 1)
                }
                #[cfg(not(feature = "gpu"))]
                {
                    Device::Cpu
                }
            };

            partitions.push(ModelPartition {
                device,
                layer_range: (start_layer, end_layer),
                parameter_count,
                memory_usage_mb: memory_usage,
            });
        }

        Ok(partitions)
    }

    /// Estimate memory usage for given number of parameters
    fn estimate_memory_usage(&self, parameter_count: usize) -> f64 {
        let bytes_per_param = if self.config.enable_mixed_precision {
            2.0 // FP16
        } else {
            4.0 // FP32
        };

        // Parameter storage + gradients + optimizer states (Adam requires 2x parameters)
        let total_bytes = parameter_count as f64 * bytes_per_param * 3.0;
        total_bytes / (1024.0 * 1024.0) // Convert to MB
    }

    /// Calculate memory savings from optimizations
    fn calculate_memory_savings(
        &self,
        total_parameters: usize,
        _checkpoint_points: &[usize],
    ) -> MemorySavings {
        let base_memory = self.estimate_memory_usage(total_parameters);

        // Gradient checkpointing saves activation memory
        let checkpointing_savings = if self.config.enable_gradient_checkpointing {
            base_memory * 0.3 // Estimate 30% savings from checkpointing
        } else {
            0.0
        };

        // Parameter offloading saves GPU memory
        let offloading_savings = if self.config.enable_parameter_offloading {
            base_memory * 0.5 // Estimate 50% of parameters can be offloaded
        } else {
            0.0
        };

        // Mixed precision saves memory
        let mixed_precision_savings = if self.config.enable_mixed_precision {
            base_memory * 0.5 // FP16 uses half the memory
        } else {
            0.0
        };

        MemorySavings {
            baseline_memory_mb: base_memory,
            checkpointing_savings_mb: checkpointing_savings,
            offloading_savings_mb: offloading_savings,
            mixed_precision_savings_mb: mixed_precision_savings,
            total_savings_mb: checkpointing_savings + offloading_savings + mixed_precision_savings,
        }
    }

    /// Estimate peak memory usage
    fn estimate_peak_memory(&self, partitions: &[ModelPartition]) -> f64 {
        if partitions.len() <= 1 {
            partitions.first().map(|p| p.memory_usage_mb).unwrap_or(0.0)
        } else {
            // Model parallelism distributes memory across devices
            partitions
                .iter()
                .map(|p| p.memory_usage_mb)
                .fold(0.0, f64::max)
        }
    }

    /// Recommend optimal batch size
    fn recommend_batch_size(&self, total_parameters: usize) -> usize {
        let memory_per_device = self.config.max_memory_per_device_mb as f64;
        let model_memory = self.estimate_memory_usage(total_parameters);
        let available_memory = memory_per_device - model_memory;

        // Estimate memory per batch item (rough approximation)
        let memory_per_batch_item = (total_parameters as f64 * 4.0) / (1024.0 * 1024.0); // 4 bytes per param

        let max_batch_size = (available_memory / memory_per_batch_item) as usize;

        // Return a reasonable batch size, capped at 32 for very large models
        max_batch_size.clamp(1, 32)
    }

    /// Generate optimization recommendations
    fn generate_optimization_recommendations(&self, total_parameters: usize) -> Vec<String> {
        let mut recommendations = Vec::new();

        if total_parameters >= 1_000_000_000 {
            // 1B+ parameters
            recommendations
                .push("Enable gradient checkpointing to reduce memory usage".to_string());
            recommendations.push("Consider model parallelism across multiple GPUs".to_string());
            recommendations.push("Use mixed precision (FP16) training".to_string());
            recommendations.push("Enable parameter offloading for very large models".to_string());
        }

        if total_parameters >= 10_000_000_000 {
            // 10B+ parameters
            recommendations
                .push("Consider gradient accumulation with smaller micro-batches".to_string());
            recommendations.push("Use ZeRO optimizer state partitioning".to_string());
            recommendations
                .push("Implement activation recomputation for memory efficiency".to_string());
        }

        if self.config.num_devices > 1 {
            recommendations
                .push("Optimize communication patterns for model parallelism".to_string());
            recommendations.push("Consider pipeline parallelism for very deep models".to_string());
        }

        recommendations
    }

    /// Create gradient checkpoint
    pub fn create_checkpoint(
        &self,
        layer_index: usize,
        activations: Vec<Box<dyn std::any::Any + Send + Sync>>,
    ) -> Result<()> {
        if !self.config.enable_gradient_checkpointing {
            return Ok(());
        }

        let memory_usage = activations.len() as f64 * 4.0 / (1024.0 * 1024.0); // Estimate 4 bytes per activation

        let checkpoint = GradientCheckpoint {
            layer_index,
            activations,
            timestamp: Instant::now(),
            memory_usage_mb: memory_usage,
        };

        self.checkpoints
            .write()
            .expect("checkpoints write lock should not be poisoned")
            .insert(layer_index, checkpoint);

        // Update stats
        {
            let mut stats = self.stats.lock().expect("lock should not be poisoned");
            stats.memory_saved_by_checkpointing_mb += memory_usage * 0.7; // Estimate 70% savings
        }

        Ok(())
    }

    /// Offload parameter to CPU memory
    pub fn offload_parameter(
        &self,
        name: &str,
        data: &[u8],
        shape: Vec<usize>,
        dtype: DType,
    ) -> Result<()> {
        if !self.config.enable_parameter_offloading {
            return Ok(());
        }

        let memory_size = data.len() as f64 / (1024.0 * 1024.0);

        let offloaded = OffloadedParameter {
            name: name.to_string(),
            shape,
            dtype,
            cpu_storage: data.to_vec(),
            last_accessed: Instant::now(),
            access_count: 0,
        };

        self.offloaded_parameters
            .write()
            .expect("offloaded parameters write lock should not be poisoned")
            .insert(name.to_string(), offloaded);

        // Update stats
        {
            let mut stats = self.stats.lock().expect("lock should not be poisoned");
            stats.memory_saved_by_offloading_mb += memory_size;
        }

        Ok(())
    }

    /// Get optimization statistics
    pub fn get_optimization_stats(&self) -> MemoryOptimizationStats {
        self.stats
            .lock()
            .expect("lock should not be poisoned")
            .clone()
    }

    /// Generate optimization report
    pub fn generate_optimization_report(&self) -> LargeModelOptimizationReport {
        let stats = self.get_optimization_stats();
        let partitions = self
            .partitions
            .read()
            .expect("read lock should not be poisoned")
            .clone();
        let checkpoint_count = self
            .checkpoints
            .read()
            .expect("read lock should not be poisoned")
            .len();
        let offloaded_count = self
            .offloaded_parameters
            .read()
            .expect("read lock should not be poisoned")
            .len();

        let total_memory_saved_mb = stats.memory_saved_by_checkpointing_mb
            + stats.memory_saved_by_offloading_mb
            + stats.memory_saved_by_mixed_precision_mb;

        LargeModelOptimizationReport {
            config: self.config.clone(),
            stats,
            partitions,
            checkpoint_count,
            offloaded_parameters_count: offloaded_count,
            total_memory_saved_mb,
        }
    }
}

/// Model execution plan for large models
#[derive(Debug, Clone)]
pub struct ModelExecutionPlan {
    pub partitions: Vec<ModelPartition>,
    pub checkpoint_points: Vec<usize>,
    pub memory_savings: MemorySavings,
    pub estimated_peak_memory_mb: f64,
    pub recommended_batch_size: usize,
    pub optimization_recommendations: Vec<String>,
}

/// Memory savings breakdown
#[derive(Debug, Clone)]
pub struct MemorySavings {
    pub baseline_memory_mb: f64,
    pub checkpointing_savings_mb: f64,
    pub offloading_savings_mb: f64,
    pub mixed_precision_savings_mb: f64,
    pub total_savings_mb: f64,
}

/// Large model optimization report
#[derive(Debug, Clone)]
pub struct LargeModelOptimizationReport {
    pub config: LargeModelConfig,
    pub stats: MemoryOptimizationStats,
    pub partitions: Vec<ModelPartition>,
    pub checkpoint_count: usize,
    pub offloaded_parameters_count: usize,
    pub total_memory_saved_mb: f64,
}

impl LargeModelOptimizationReport {
    /// Print a formatted optimization report
    pub fn print_report(&self) {
        println!("🤖 Large Model Optimization Report (1B+ Parameters)");
        println!("=================================================");
        println!();

        println!("📊 Model Statistics:");
        println!(
            "  • Total parameters: {:.1}B",
            self.stats.total_parameters as f64 / 1_000_000_000.0
        );
        println!(
            "  • Peak memory usage: {:.1} MB",
            self.stats.peak_memory_usage_mb
        );
        println!(
            "  • Memory efficiency: {:.1}%",
            self.stats.memory_efficiency * 100.0
        );
        println!();

        println!("⚡ Optimization Features:");
        println!(
            "  • Gradient checkpointing: {}",
            self.config.enable_gradient_checkpointing
        );
        println!(
            "  • Model parallelism: {}",
            self.config.enable_model_parallelism
        );
        println!(
            "  • Parameter offloading: {}",
            self.config.enable_parameter_offloading
        );
        println!(
            "  • Mixed precision: {}",
            self.config.enable_mixed_precision
        );
        println!("  • Dynamic memory: {}", self.config.enable_dynamic_memory);
        println!();

        println!("💾 Memory Optimizations:");
        println!(
            "  • Checkpointing savings: {:.1} MB",
            self.stats.memory_saved_by_checkpointing_mb
        );
        println!(
            "  • Offloading savings: {:.1} MB",
            self.stats.memory_saved_by_offloading_mb
        );
        println!(
            "  • Mixed precision savings: {:.1} MB",
            self.stats.memory_saved_by_mixed_precision_mb
        );
        println!("  • Total savings: {:.1} MB", self.total_memory_saved_mb);
        println!();

        if !self.partitions.is_empty() {
            println!("🔗 Model Partitions:");
            for (i, partition) in self.partitions.iter().enumerate() {
                println!(
                    "  Partition {}: {:?} - Layers {}-{} ({:.1}M params, {:.1} MB)",
                    i,
                    partition.device,
                    partition.layer_range.0,
                    partition.layer_range.1,
                    partition.parameter_count as f64 / 1_000_000.0,
                    partition.memory_usage_mb
                );
            }
            println!();
        }

        println!("📈 Runtime Statistics:");
        println!("  • Active checkpoints: {}", self.checkpoint_count);
        println!(
            "  • Offloaded parameters: {}",
            self.offloaded_parameters_count
        );
        println!(
            "  • Parallelism overhead: {:.1} MB",
            self.stats.parallelism_overhead_mb
        );

        println!();
        println!("=================================================");
    }
}

lazy_static::lazy_static! {
    pub static ref LARGE_MODEL_OPTIMIZER: LargeModelOptimizer =
        LargeModelOptimizer::new(LargeModelConfig::default());
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_large_model_config() {
        let config = LargeModelConfig::default();
        assert!(config.enable_gradient_checkpointing);
        assert!(config.enable_model_parallelism);
        assert_eq!(config.checkpoint_granularity, 4);
    }

    #[test]
    fn test_memory_estimation() {
        let optimizer = LargeModelOptimizer::new(LargeModelConfig::default());
        let memory = optimizer.estimate_memory_usage(1_000_000); // 1M parameters
        assert!(memory > 0.0);
    }

    #[test]
    fn test_model_analysis() {
        let optimizer = LargeModelOptimizer::new(LargeModelConfig::default());
        let plan = optimizer
            .analyze_model(100, 10_000_000)
            .expect("test: analyze_model should succeed"); // 1B parameters
        assert!(!plan.optimization_recommendations.is_empty());
        assert!(plan.estimated_peak_memory_mb > 0.0);
    }
}