voirs-sdk 0.1.0-rc.1

//! Memory optimization strategies and utilities
//!
//! Provides advanced memory optimization techniques including layout optimization,
//! copy elimination, memory mapping, and lazy loading strategies.

use memmap2::{Mmap, MmapOptions};
use std::collections::HashMap;
use std::fs::File;
use std::io;
use std::path::{Path, PathBuf};
use std::sync::{Arc, RwLock};

/// Memory optimization strategies
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OptimizationStrategy {
    /// Minimize memory usage at cost of performance
    MinimizeMemory,
    /// Maximize performance at cost of memory
    MaximizePerformance,
    /// Balance between memory and performance
    Balanced,
    /// Custom strategy with specific parameters
    Custom,
}

/// Memory layout optimization configuration
#[derive(Debug, Clone)]
pub struct LayoutConfig {
    /// Target alignment for data structures
    pub alignment: usize,
    /// Enable structure packing
    pub enable_packing: bool,
    /// Cache line size for optimization
    pub cache_line_size: usize,
    /// Enable NUMA-aware placement
    pub numa_aware: bool,
}

impl Default for LayoutConfig {
    fn default() -> Self {
        Self {
            alignment: 64, // Common cache line size
            enable_packing: true,
            cache_line_size: 64,
            numa_aware: false,
        }
    }
}

/// Memory layout optimizer
pub struct MemoryLayout {
    config: LayoutConfig,
    optimization_stats: Arc<RwLock<OptimizationStats>>,
}

/// Optimization statistics
#[derive(Debug, Clone, Default)]
pub struct OptimizationStats {
    /// Number of layout optimizations performed
    pub optimizations_performed: u64,
    /// Memory saved through optimization (bytes)
    pub memory_saved: u64,
    /// Performance improvement ratio
    pub performance_improvement: f64,
    /// Cache hit ratio improvement
    pub cache_hit_improvement: f64,
}

impl MemoryLayout {
    /// Create a new memory layout optimizer
    pub fn new(config: LayoutConfig) -> Self {
        Self {
            config,
            optimization_stats: Arc::new(RwLock::new(OptimizationStats::default())),
        }
    }

    /// Optimize data structure layout for cache efficiency
    pub fn optimize_struct_layout<T>(
        &self,
        data: &mut [T],
        access_pattern: AccessPattern,
    ) -> usize {
        let _original_size = std::mem::size_of_val(data);

        match access_pattern {
            AccessPattern::Sequential => {
                // Already optimal for sequential access
                0
            }
            AccessPattern::Random => {
                // Optimize for random access by improving cache locality
                self.optimize_for_random_access(data)
            }
            AccessPattern::Strided => {
                // Optimize for strided access patterns
                self.optimize_for_strided_access(data)
            }
        }
    }

    /// Calculate optimal alignment for given data size
    pub fn calculate_optimal_alignment(&self, size: usize) -> usize {
        // Find the largest power of 2 that divides size and is <= cache_line_size
        let mut alignment = 1;
        while alignment <= self.config.cache_line_size
            && alignment <= size
            && size.is_multiple_of(alignment)
        {
            alignment *= 2;
        }
        alignment / 2
    }

    /// Analyze memory access patterns to suggest optimizations
    pub fn analyze_access_pattern(&self, accesses: &[MemoryAccess]) -> AccessAnalysis {
        let mut sequential_count = 0;
        let mut random_count = 0;
        let mut stride_patterns = HashMap::new();

        for window in accesses.windows(2) {
            let addr_diff = window[1].address.saturating_sub(window[0].address);

            if addr_diff <= 64 {
                // Within cache line
                sequential_count += 1;
            } else if addr_diff > 1024 {
                // Far apart
                random_count += 1;
            } else {
                *stride_patterns.entry(addr_diff).or_insert(0) += 1;
            }
        }

        let total = accesses.len() - 1;
        let sequential_ratio = if total > 0 {
            sequential_count as f64 / total as f64
        } else {
            0.0
        };
        let random_ratio = if total > 0 {
            random_count as f64 / total as f64
        } else {
            0.0
        };

        let dominant_pattern = if sequential_ratio > 0.7 {
            AccessPattern::Sequential
        } else if random_ratio > 0.7 {
            AccessPattern::Random
        } else {
            AccessPattern::Strided
        };

        AccessAnalysis {
            dominant_pattern,
            sequential_ratio,
            random_ratio,
            stride_patterns,
            cache_line_utilization: self.calculate_cache_utilization(accesses),
        }
    }

    /// Get optimization statistics
    pub fn get_stats(&self) -> OptimizationStats {
        self.optimization_stats
            .read()
            .map(|stats| stats.clone())
            .unwrap_or_default()
    }

    // Helper methods

    fn optimize_for_random_access<T>(&self, _data: &mut [T]) -> usize {
        // In a real implementation, this might reorder data or use hash tables
        // For now, return 0 savings
        0
    }

    fn optimize_for_strided_access<T>(&self, _data: &mut [T]) -> usize {
        // In a real implementation, this might reorganize data to improve stride access
        0
    }

    fn calculate_cache_utilization(&self, accesses: &[MemoryAccess]) -> f64 {
        if accesses.is_empty() {
            return 0.0;
        }

        let mut cache_lines_accessed = std::collections::HashSet::new();
        for access in accesses {
            let cache_line = access.address / self.config.cache_line_size;
            cache_lines_accessed.insert(cache_line);
        }

        let total_bytes = accesses.iter().map(|a| a.size).sum::<usize>();
        let cache_lines_needed = total_bytes.div_ceil(self.config.cache_line_size);

        if cache_lines_needed > 0 {
            cache_lines_accessed.len() as f64 / cache_lines_needed as f64
        } else {
            0.0
        }
    }
}

/// Memory access pattern types
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AccessPattern {
    /// Sequential access (good cache locality)
    Sequential,
    /// Random access (poor cache locality)
    Random,
    /// Strided access (predictable but may have cache misses)
    Strided,
}

/// Memory access information
#[derive(Debug, Clone)]
pub struct MemoryAccess {
    /// Memory address accessed
    pub address: usize,
    /// Size of access in bytes
    pub size: usize,
    /// Access timestamp
    pub timestamp: std::time::Instant,
    /// Access type (read/write)
    pub access_type: AccessType,
}

/// Type of memory access
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AccessType {
    Read,
    Write,
    ReadWrite,
}

/// Analysis of memory access patterns
#[derive(Debug, Clone)]
pub struct AccessAnalysis {
    /// Dominant access pattern
    pub dominant_pattern: AccessPattern,
    /// Ratio of sequential accesses
    pub sequential_ratio: f64,
    /// Ratio of random accesses
    pub random_ratio: f64,
    /// Common stride patterns
    pub stride_patterns: HashMap<usize, usize>,
    /// Cache line utilization efficiency
    pub cache_line_utilization: f64,
}

/// Memory-mapped file wrapper for efficient large file access
pub struct MappedFile {
    /// Memory map
    mmap: Mmap,
    /// File path
    #[allow(dead_code)]
    path: PathBuf,
    /// File size
    size: usize,
}

impl MappedFile {
    /// Open a file with memory mapping
    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<Self> {
        let file = File::open(&path)?;
        let metadata = file.metadata()?;
        let size = metadata.len() as usize;

        let mmap = unsafe { MmapOptions::new().map(&file)? };

        Ok(Self {
            mmap,
            path: path.as_ref().to_path_buf(),
            size,
        })
    }

    /// Get a slice of the mapped data
    pub fn get_slice(&self, offset: usize, length: usize) -> Option<&[u8]> {
        if offset + length <= self.size {
            Some(&self.mmap[offset..offset + length])
        } else {
            None
        }
    }

    /// Get the entire mapped data
    pub fn as_slice(&self) -> &[u8] {
        &self.mmap
    }

    /// Get file size
    pub fn len(&self) -> usize {
        self.size
    }

    /// Check if file is empty
    pub fn is_empty(&self) -> bool {
        self.size == 0
    }

    /// Prefetch a range of data
    pub fn prefetch(&self, offset: usize, length: usize) -> io::Result<()> {
        if offset + length <= self.size {
            // On Unix systems, we could use madvise with MADV_WILLNEED
            // For now, this is a no-op placeholder
            Ok(())
        } else {
            Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "Range out of bounds",
            ))
        }
    }
}

/// Lazy loading container for memory optimization
pub struct LazyData<T> {
    /// Optional loaded data
    data: Arc<RwLock<Option<T>>>,
    /// Loader function
    loader: Box<dyn Fn() -> Result<T, Box<dyn std::error::Error + Send + Sync>> + Send + Sync>,
    /// Loading statistics
    load_count: Arc<std::sync::atomic::AtomicU64>,
}

impl<T> LazyData<T>
where
    T: Clone + Send + Sync + 'static,
{
    /// Create a new lazy data container
    pub fn new<F>(loader: F) -> Self
    where
        F: Fn() -> Result<T, Box<dyn std::error::Error + Send + Sync>> + Send + Sync + 'static,
    {
        Self {
            data: Arc::new(RwLock::new(None)),
            loader: Box::new(loader),
            load_count: Arc::new(std::sync::atomic::AtomicU64::new(0)),
        }
    }

    /// Get the data, loading it if necessary
    pub fn get(&self) -> Result<T, Box<dyn std::error::Error + Send + Sync>> {
        // Try to read existing data first
        if let Ok(data_guard) = self.data.read() {
            if let Some(ref data) = *data_guard {
                return Ok(data.clone());
            }
        }

        // Need to load data
        let loaded_data = (self.loader)()?;
        self.load_count
            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);

        // Store the loaded data
        if let Ok(mut data_guard) = self.data.write() {
            *data_guard = Some(loaded_data.clone());
        }

        Ok(loaded_data)
    }

    /// Check if data is currently loaded
    pub fn is_loaded(&self) -> bool {
        if let Ok(data_guard) = self.data.read() {
            data_guard.is_some()
        } else {
            false
        }
    }

    /// Unload data to free memory
    pub fn unload(&self) {
        if let Ok(mut data_guard) = self.data.write() {
            *data_guard = None;
        }
    }

    /// Get number of times data has been loaded
    pub fn load_count(&self) -> u64 {
        self.load_count.load(std::sync::atomic::Ordering::Relaxed)
    }
}

/// Memory optimizer that coordinates various optimization strategies
pub struct MemoryOptimizer {
    /// Layout optimizer
    layout: MemoryLayout,
    /// Mapped files cache
    mapped_files: Arc<RwLock<HashMap<PathBuf, Arc<MappedFile>>>>,
    /// Optimization strategy
    strategy: OptimizationStrategy,
    /// Configuration
    config: OptimizerConfig,
}

/// Memory optimizer configuration
#[derive(Debug, Clone)]
pub struct OptimizerConfig {
    /// Enable aggressive optimizations
    pub aggressive_optimization: bool,
    /// Memory pressure threshold (0.0 - 1.0)
    pub memory_pressure_threshold: f64,
    /// Enable copy elimination
    pub enable_copy_elimination: bool,
    /// Maximum memory for caching mapped files
    pub max_mapped_cache_size: usize,
}

impl Default for OptimizerConfig {
    fn default() -> Self {
        Self {
            aggressive_optimization: false,
            memory_pressure_threshold: 0.8,
            enable_copy_elimination: true,
            max_mapped_cache_size: 1024 * 1024 * 1024, // 1GB
        }
    }
}

impl MemoryOptimizer {
    /// Create a new memory optimizer
    pub fn new(strategy: OptimizationStrategy, config: OptimizerConfig) -> Self {
        let layout_config = match strategy {
            OptimizationStrategy::MinimizeMemory => LayoutConfig {
                alignment: 8,
                enable_packing: true,
                cache_line_size: 64,
                numa_aware: false,
            },
            OptimizationStrategy::MaximizePerformance => LayoutConfig {
                alignment: 64,
                enable_packing: false,
                cache_line_size: 64,
                numa_aware: true,
            },
            OptimizationStrategy::Balanced => LayoutConfig::default(),
            OptimizationStrategy::Custom => LayoutConfig::default(),
        };

        Self {
            layout: MemoryLayout::new(layout_config),
            mapped_files: Arc::new(RwLock::new(HashMap::new())),
            strategy,
            config,
        }
    }

    /// Get or create a memory-mapped file
    pub fn get_mapped_file<P: AsRef<Path>>(&self, path: P) -> io::Result<Arc<MappedFile>> {
        let path_buf = path.as_ref().to_path_buf();

        // Check cache first
        if let Ok(cache) = self.mapped_files.read() {
            if let Some(mapped_file) = cache.get(&path_buf) {
                return Ok(Arc::clone(mapped_file));
            }
        }

        // Create new mapped file
        let mapped_file = Arc::new(MappedFile::open(&path_buf)?);

        // Add to cache
        if let Ok(mut cache) = self.mapped_files.write() {
            // Check cache size limit
            let current_size: usize = cache.values().map(|f| f.len()).sum();
            if current_size + mapped_file.len() > self.config.max_mapped_cache_size {
                // Remove oldest entries to make space
                let paths_to_remove: Vec<_> = cache.keys().cloned().collect();
                for old_path in paths_to_remove {
                    cache.remove(&old_path);
                    let new_size: usize = cache.values().map(|f| f.len()).sum();
                    if new_size + mapped_file.len() <= self.config.max_mapped_cache_size {
                        break;
                    }
                }
            }

            cache.insert(path_buf, Arc::clone(&mapped_file));
        }

        Ok(mapped_file)
    }

    /// Optimize memory layout based on access patterns
    pub fn optimize_layout<T>(
        &self,
        data: &mut [T],
        accesses: &[MemoryAccess],
    ) -> OptimizationResult {
        let analysis = self.layout.analyze_access_pattern(accesses);
        let memory_saved = self
            .layout
            .optimize_struct_layout(data, analysis.dominant_pattern);

        OptimizationResult {
            memory_saved,
            performance_improvement: self.estimate_performance_improvement(&analysis),
            access_analysis: analysis,
        }
    }

    /// Create a copy-elimination wrapper for zero-copy operations
    pub fn create_zero_copy_view<'a, T>(&self, data: &'a [T]) -> ZeroCopyView<'a, T> {
        ZeroCopyView::new(data)
    }

    /// Get comprehensive optimization report
    pub fn get_optimization_report(&self) -> OptimizationReport {
        let layout_stats = self.layout.get_stats();
        let mapped_files_count = self
            .mapped_files
            .read()
            .map(|files| files.len())
            .unwrap_or(0);

        OptimizationReport {
            strategy: self.strategy,
            layout_stats,
            mapped_files_count,
            total_mapped_size: self.get_total_mapped_size(),
        }
    }

    // Helper methods

    fn estimate_performance_improvement(&self, analysis: &AccessAnalysis) -> f64 {
        // Estimate based on cache efficiency
        let baseline_performance = 1.0;
        let cache_efficiency_bonus = analysis.cache_line_utilization * 0.3; // Up to 30% improvement
        baseline_performance + cache_efficiency_bonus
    }

    fn get_total_mapped_size(&self) -> usize {
        if let Ok(cache) = self.mapped_files.read() {
            cache.values().map(|f| f.len()).sum()
        } else {
            0
        }
    }
}

/// Zero-copy view wrapper
pub struct ZeroCopyView<'a, T> {
    data: &'a [T],
}

impl<'a, T> ZeroCopyView<'a, T> {
    fn new(data: &'a [T]) -> Self {
        Self { data }
    }

    /// Get slice without copying
    pub fn as_slice(&self) -> &[T] {
        self.data
    }

    /// Get length
    pub fn len(&self) -> usize {
        self.data.len()
    }

    /// Check if empty
    pub fn is_empty(&self) -> bool {
        self.data.is_empty()
    }
}

/// Result of memory optimization
#[derive(Debug, Clone)]
pub struct OptimizationResult {
    /// Memory saved in bytes
    pub memory_saved: usize,
    /// Performance improvement factor
    pub performance_improvement: f64,
    /// Access pattern analysis
    pub access_analysis: AccessAnalysis,
}

/// Comprehensive optimization report
#[derive(Debug, Clone)]
pub struct OptimizationReport {
    /// Current optimization strategy
    pub strategy: OptimizationStrategy,
    /// Layout optimization statistics
    pub layout_stats: OptimizationStats,
    /// Number of mapped files
    pub mapped_files_count: usize,
    /// Total size of mapped files
    pub total_mapped_size: usize,
}

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

    #[test]
    fn test_memory_layout_optimization() {
        let config = LayoutConfig::default();
        let layout = MemoryLayout::new(config);

        let mut data = vec![1u32, 2, 3, 4, 5];
        let access_pattern = AccessPattern::Sequential;

        let saved = layout.optimize_struct_layout(&mut data, access_pattern);
        assert_eq!(saved, 0); // Sequential is already optimal
    }

    #[test]
    fn test_access_pattern_analysis() {
        let layout = MemoryLayout::new(LayoutConfig::default());

        let accesses = vec![
            MemoryAccess {
                address: 0x1000,
                size: 4,
                timestamp: Instant::now(),
                access_type: AccessType::Read,
            },
            MemoryAccess {
                address: 0x1004,
                size: 4,
                timestamp: Instant::now(),
                access_type: AccessType::Read,
            },
            MemoryAccess {
                address: 0x1008,
                size: 4,
                timestamp: Instant::now(),
                access_type: AccessType::Read,
            },
        ];

        let analysis = layout.analyze_access_pattern(&accesses);
        assert_eq!(analysis.dominant_pattern, AccessPattern::Sequential);
        assert!(analysis.sequential_ratio > 0.5);
    }

    #[test]
    fn test_lazy_data() {
        let lazy = LazyData::new(|| Ok(String::from("Hello, World!")));

        assert!(!lazy.is_loaded());
        assert_eq!(lazy.load_count(), 0);

        let data = lazy.get().unwrap();
        assert_eq!(data, "Hello, World!");
        assert!(lazy.is_loaded());
        assert_eq!(lazy.load_count(), 1);

        // Second access should not reload
        let data2 = lazy.get().unwrap();
        assert_eq!(data2, "Hello, World!");
        assert_eq!(lazy.load_count(), 1);
    }

    #[test]
    fn test_zero_copy_view() {
        let data = vec![1, 2, 3, 4, 5];
        let optimizer =
            MemoryOptimizer::new(OptimizationStrategy::Balanced, OptimizerConfig::default());

        let view = optimizer.create_zero_copy_view(&data);
        assert_eq!(view.len(), 5);
        assert_eq!(view.as_slice(), &[1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_optimization_alignment() {
        let layout = MemoryLayout::new(LayoutConfig::default());

        assert_eq!(layout.calculate_optimal_alignment(64), 64);
        assert_eq!(layout.calculate_optimal_alignment(32), 32);
        assert_eq!(layout.calculate_optimal_alignment(17), 1);
        assert_eq!(layout.calculate_optimal_alignment(128), 64); // Capped at cache line size
    }
}