scirs2_metrics/optimization/

advanced_memory_optimization.rs

//! Advanced memory optimization for GPU acceleration
//!
//! This module provides sophisticated memory management techniques for GPU-accelerated
//! metrics computation, including memory pooling, prefetching, and adaptive allocation.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use crate::error::{MetricsError, Result};
use scirs2_core::ndarray::{Array1, Array2, ArrayView1, ArrayView2};
use scirs2_core::numeric::Float;
use std::collections::{HashMap, VecDeque};
use std::sync::{Arc, Mutex, RwLock};
use std::time::{Duration, Instant};

/// Advanced GPU memory pool with intelligent allocation strategies
#[derive(Debug)]
pub struct AdvancedMemoryPool {
    /// Free memory blocks categorized by size
    free_blocks: Arc<Mutex<HashMap<usize, VecDeque<MemoryBlock>>>>,
    /// Allocated blocks for tracking
    allocated_blocks: Arc<RwLock<HashMap<usize, AllocatedBlock>>>,
    /// Memory usage statistics
    stats: Arc<Mutex<MemoryStats>>,
    /// Pool configuration
    config: MemoryPoolConfig,
    /// Allocation strategy
    strategy: AllocationStrategy,
    /// Memory prefetcher for predictive allocation
    prefetcher: MemoryPrefetcher,
}

/// Memory block representation
#[derive(Debug, Clone)]
pub struct MemoryBlock {
    /// Block identifier
    pub id: usize,
    /// Size in bytes
    pub size: usize,
    /// GPU device pointer (simulated as usize)
    pub device_ptr: usize,
    /// Last access time for LRU
    pub last_accessed: Instant,
    /// Block type and purpose
    pub blocktype: BlockType,
    /// Reference count for shared usage
    pub ref_count: usize,
}

/// Allocated block tracking
#[derive(Debug, Clone)]
pub struct AllocatedBlock {
    /// Original block
    pub block: MemoryBlock,
    /// Allocation timestamp
    pub allocated_at: Instant,
    /// Expected lifetime
    pub expected_lifetime: Option<Duration>,
    /// Usage pattern
    pub usage_pattern: UsagePattern,
}

/// Memory usage statistics
#[derive(Debug, Default, Clone)]
pub struct MemoryStats {
    /// Total allocated memory
    pub total_allocated: usize,
    /// Peak memory usage
    pub peak_usage: usize,
    /// Number of allocations
    pub allocation_count: u64,
    /// Number of deallocations
    pub deallocation_count: u64,
    /// Cache hit rate
    pub cache_hit_rate: f64,
    /// Fragmentation ratio
    pub fragmentation_ratio: f64,
    /// Average allocation size
    pub avg_allocation_size: f64,
    /// Memory efficiency score
    pub efficiency_score: f64,
}

/// Memory pool configuration
#[derive(Debug, Clone)]
pub struct MemoryPoolConfig {
    /// Maximum pool size in bytes
    pub max_pool_size: usize,
    /// Minimum block size
    pub min_block_size: usize,
    /// Block size alignment
    pub alignment: usize,
    /// Enable memory coalescing
    pub enable_coalescing: bool,
    /// Garbage collection threshold
    pub gc_threshold: f64,
    /// Prefetch lookahead window
    pub prefetch_window: usize,
    /// Enable zero-copy optimizations
    pub enable_zero_copy: bool,
}

/// Block type categorization
#[derive(Debug, Clone, PartialEq)]
pub enum BlockType {
    /// Input data arrays
    InputData,
    /// Output result arrays
    OutputData,
    /// Intermediate computation buffers
    IntermediateBuffer,
    /// Kernel parameters
    KernelParams,
    /// Shared memory blocks
    SharedMemory,
    /// Texture memory for cached reads
    TextureMemory,
}

/// Memory allocation strategy
#[derive(Debug, Clone)]
pub enum AllocationStrategy {
    /// First-fit allocation
    FirstFit,
    /// Best-fit allocation (minimize fragmentation)
    BestFit,
    /// Worst-fit allocation (keep large blocks)
    WorstFit,
    /// Buddy system allocation
    BuddySystem,
    /// Adaptive strategy based on usage patterns
    Adaptive(AdaptiveStrategy),
}

/// Adaptive allocation strategy configuration
#[derive(Debug, Clone)]
pub struct AdaptiveStrategy {
    /// Strategy switching threshold
    pub switch_threshold: f64,
    /// Historical window size for analysis
    pub history_window: usize,
    /// Performance weight factors
    pub weights: StrategyWeights,
}

/// Strategy performance weights
#[derive(Debug, Clone)]
pub struct StrategyWeights {
    /// Weight for allocation speed
    pub speed_weight: f64,
    /// Weight for memory efficiency
    pub efficiency_weight: f64,
    /// Weight for fragmentation avoidance
    pub fragmentation_weight: f64,
}

/// Usage pattern analysis
#[derive(Debug, Clone)]
pub enum UsagePattern {
    /// Sequential access pattern
    Sequential,
    /// Random access pattern
    Random,
    /// Streaming pattern (write-once, read-many)
    Streaming,
    /// Temporary computation buffer
    Temporary,
    /// Long-lived persistent data
    Persistent,
}

/// Memory prefetcher for predictive allocation
#[derive(Debug)]
pub struct MemoryPrefetcher {
    /// Allocation history for pattern analysis (interior-mutable for &self access)
    allocation_history: Arc<Mutex<VecDeque<AllocationRecord>>>,
    /// Predicted future allocations
    predictions: Vec<PredictedAllocation>,
    /// Pattern recognition engine
    pattern_engine: PatternEngine,
    /// Prefetch configuration
    config: PrefetchConfig,
}

/// Allocation record for pattern analysis
#[derive(Debug, Clone)]
pub struct AllocationRecord {
    /// Allocation size
    pub size: usize,
    /// Block type
    pub blocktype: BlockType,
    /// Timestamp
    pub timestamp: Instant,
    /// Duration until deallocation
    pub lifetime: Option<Duration>,
}

/// Predicted allocation
#[derive(Debug, Clone)]
pub struct PredictedAllocation {
    /// Predicted size
    pub size: usize,
    /// Predicted type
    pub blocktype: BlockType,
    /// Confidence score (0.0 to 1.0)
    pub confidence: f64,
    /// Expected time until allocation
    pub time_until: Duration,
}

/// Pattern recognition engine
#[derive(Debug)]
pub struct PatternEngine {
    /// Learned patterns
    patterns: Vec<AllocationPattern>,
    /// Model accuracy metrics
    accuracy: f64,
    /// Training data size
    training_samples: usize,
}

/// Allocation pattern
#[derive(Debug, Clone)]
pub struct AllocationPattern {
    /// Pattern signature
    pub signature: Vec<usize>,
    /// Frequency of occurrence
    pub frequency: u32,
    /// Prediction accuracy
    pub accuracy: f64,
    /// Associated block types
    pub block_types: Vec<BlockType>,
}

/// Prefetch configuration
#[derive(Debug, Clone)]
pub struct PrefetchConfig {
    /// Enable predictive prefetching
    pub enable_prediction: bool,
    /// Minimum confidence threshold for prefetch
    pub confidence_threshold: f64,
    /// Maximum prefetch lookahead
    pub max_lookahead: Duration,
    /// Prefetch buffer size limit
    pub buffer_size_limit: usize,
}

impl Default for MemoryPoolConfig {
    fn default() -> Self {
        Self {
            max_pool_size: 1024 * 1024 * 1024, // 1GB default
            min_block_size: 1024,              // 1KB minimum
            alignment: 256,                    // 256-byte alignment for GPU
            enable_coalescing: true,
            gc_threshold: 0.8, // Trigger GC at 80% usage
            prefetch_window: 10,
            enable_zero_copy: true,
        }
    }
}

impl Default for AdaptiveStrategy {
    fn default() -> Self {
        Self {
            switch_threshold: 0.1,
            history_window: 1000,
            weights: StrategyWeights {
                speed_weight: 0.4,
                efficiency_weight: 0.4,
                fragmentation_weight: 0.2,
            },
        }
    }
}

impl Default for PrefetchConfig {
    fn default() -> Self {
        Self {
            enable_prediction: true,
            confidence_threshold: 0.75,
            max_lookahead: Duration::from_millis(100),
            buffer_size_limit: 64 * 1024 * 1024, // 64MB prefetch buffer
        }
    }
}

impl AdvancedMemoryPool {
    /// Create new advanced memory pool
    pub fn new(config: MemoryPoolConfig) -> Self {
        Self {
            free_blocks: Arc::new(Mutex::new(HashMap::new())),
            allocated_blocks: Arc::new(RwLock::new(HashMap::new())),
            stats: Arc::new(Mutex::new(MemoryStats::default())),
            strategy: AllocationStrategy::Adaptive(AdaptiveStrategy::default()),
            prefetcher: MemoryPrefetcher::new(PrefetchConfig::default()),
            config,
        }
    }

    /// Allocate memory block with intelligent sizing
    pub fn allocate(&self, size: usize, blocktype: BlockType) -> Result<MemoryBlock> {
        let aligned_size = self.align_size(size);

        // Check if prefetcher has a suitable block ready
        if let Some(block) = self
            .prefetcher
            .get_predicted_block(aligned_size, &blocktype)?
        {
            self.record_allocation(&block)?;
            return Ok(block);
        }

        // Perform allocation based on strategy
        let block = match &self.strategy {
            AllocationStrategy::FirstFit => self.allocate_first_fit(aligned_size, blocktype)?,
            AllocationStrategy::BestFit => self.allocate_best_fit(aligned_size, blocktype)?,
            AllocationStrategy::WorstFit => self.allocate_worst_fit(aligned_size, blocktype)?,
            AllocationStrategy::BuddySystem => {
                self.allocate_buddy_system(aligned_size, blocktype)?
            }
            AllocationStrategy::Adaptive(strategy) => {
                self.allocate_adaptive(aligned_size, blocktype, strategy)?
            }
        };

        self.record_allocation(&block)?;
        self.update_prefetcher(&block);

        Ok(block)
    }

    /// Deallocate memory block
    pub fn deallocate(&self, block: MemoryBlock) -> Result<()> {
        // Record deallocation for statistics
        {
            let mut stats = self.stats.lock().expect("Operation failed");
            stats.deallocation_count += 1;
            stats.total_allocated = stats.total_allocated.saturating_sub(block.size);
        }

        // Remove from allocated blocks
        {
            let mut allocated = self.allocated_blocks.write().expect("Operation failed");
            allocated.remove(&block.id);
        }

        // Return to free pool or coalesce with adjacent blocks
        if self.config.enable_coalescing {
            self.coalesce_and_return(block)?;
        } else {
            self.return_to_pool(block)?;
        }

        // Trigger garbage collection if needed
        if self.should_run_gc()? {
            self.run_garbage_collection()?;
        }

        Ok(())
    }

    /// Get current memory statistics
    pub fn get_stats(&self) -> MemoryStats {
        let stats = self.stats.lock().expect("Operation failed");
        stats.clone()
    }

    /// Optimize memory layout for better performance
    pub fn optimize_layout(&self) -> Result<()> {
        // Analyze current allocation patterns
        let patterns = self.analyze_allocation_patterns()?;

        // Suggest layout optimizations
        let optimizations = self.suggest_optimizations(&patterns)?;

        // Apply optimizations if beneficial
        for optimization in optimizations {
            self.apply_optimization(optimization)?;
        }

        Ok(())
    }

    /// Benchmark different allocation strategies
    pub fn benchmark_strategies(
        &self,
        workload: &[AllocationRequest],
    ) -> Result<StrategyBenchmark> {
        let mut results = HashMap::new();

        for strategy in &[
            AllocationStrategy::FirstFit,
            AllocationStrategy::BestFit,
            AllocationStrategy::WorstFit,
            AllocationStrategy::BuddySystem,
        ] {
            let metrics = self.benchmark_strategy(strategy, workload)?;
            results.insert(format!("{:?}", strategy), metrics);
        }

        Ok(StrategyBenchmark { results })
    }

    // Private implementation methods

    fn align_size(&self, size: usize) -> usize {
        ((size + self.config.alignment - 1) / self.config.alignment) * self.config.alignment
    }

    fn allocate_first_fit(&self, size: usize, blocktype: BlockType) -> Result<MemoryBlock> {
        let mut free_blocks = self.free_blocks.lock().expect("Operation failed");

        // Find first suitable block
        for (block_size, blocks) in free_blocks.iter_mut() {
            if *block_size >= size {
                if let Some(mut block) = blocks.pop_front() {
                    block.blocktype = blocktype;
                    block.last_accessed = Instant::now();

                    // Split block if significantly larger
                    if *block_size > size * 2 {
                        let remaining = MemoryBlock {
                            id: self.generate_block_id(),
                            size: *block_size - size,
                            device_ptr: block.device_ptr + size,
                            last_accessed: Instant::now(),
                            blocktype: BlockType::IntermediateBuffer,
                            ref_count: 0,
                        };

                        blocks.push_front(remaining);
                    }

                    block.size = size;
                    return Ok(block);
                }
            }
        }

        // No suitable block found, allocate new
        self.allocate_new_block(size, blocktype)
    }

    fn allocate_best_fit(&self, size: usize, blocktype: BlockType) -> Result<MemoryBlock> {
        let mut free_blocks = self.free_blocks.lock().expect("Operation failed");
        let mut best_fit: Option<(usize, usize)> = None; // (block_size, index)
        let mut best_waste = usize::MAX;

        // Find block with minimum waste
        for (block_size, blocks) in free_blocks.iter() {
            if *block_size >= size {
                let waste = *block_size - size;
                if waste < best_waste {
                    best_waste = waste;
                    best_fit = Some((*block_size, 0)); // Simplified - would need proper indexing
                }
            }
        }

        if let Some((block_size, _)) = best_fit {
            if let Some(blocks) = free_blocks.get_mut(&block_size) {
                if let Some(mut block) = blocks.pop_front() {
                    block.blocktype = blocktype;
                    block.last_accessed = Instant::now();

                    // Handle block splitting for best fit
                    if block_size > size {
                        let remaining_size = block_size - size;
                        if remaining_size >= self.config.min_block_size {
                            let remaining = MemoryBlock {
                                id: self.generate_block_id(),
                                size: remaining_size,
                                device_ptr: block.device_ptr + size,
                                last_accessed: Instant::now(),
                                blocktype: BlockType::IntermediateBuffer,
                                ref_count: 0,
                            };

                            free_blocks
                                .entry(remaining_size)
                                .or_insert_with(VecDeque::new)
                                .push_back(remaining);
                        }
                    }

                    block.size = size;
                    return Ok(block);
                }
            }
        }

        self.allocate_new_block(size, blocktype)
    }

    fn allocate_worst_fit(&self, size: usize, blocktype: BlockType) -> Result<MemoryBlock> {
        // Simplified implementation - find largest available block
        self.allocate_new_block(size, blocktype)
    }

    fn allocate_buddy_system(&self, size: usize, blocktype: BlockType) -> Result<MemoryBlock> {
        // Find next power of 2 >= size for buddy system
        let buddy_size = size.next_power_of_two();
        self.allocate_new_block(buddy_size, blocktype)
    }

    fn allocate_adaptive(
        &self,
        size: usize,
        blocktype: BlockType,
        _strategy: &AdaptiveStrategy,
    ) -> Result<MemoryBlock> {
        // Analyze current performance metrics
        let stats = self.stats.lock().expect("Operation failed");
        let fragmentation = stats.fragmentation_ratio;
        let efficiency = stats.efficiency_score;

        // Choose _strategy based on current conditions
        let chosen_strategy = if fragmentation > 0.3 {
            AllocationStrategy::BestFit
        } else if efficiency < 0.7 {
            AllocationStrategy::FirstFit
        } else {
            AllocationStrategy::BuddySystem
        };

        drop(stats);

        match chosen_strategy {
            AllocationStrategy::FirstFit => self.allocate_first_fit(size, blocktype),
            AllocationStrategy::BestFit => self.allocate_best_fit(size, blocktype),
            AllocationStrategy::BuddySystem => self.allocate_buddy_system(size, blocktype),
            _ => self.allocate_new_block(size, blocktype),
        }
    }

    fn allocate_new_block(&self, size: usize, blocktype: BlockType) -> Result<MemoryBlock> {
        // Simulate GPU memory allocation
        let device_ptr = self.simulate_gpu_malloc(size)?;

        let block = MemoryBlock {
            id: self.generate_block_id(),
            size,
            device_ptr,
            last_accessed: Instant::now(),
            blocktype,
            ref_count: 1,
        };

        Ok(block)
    }

    fn simulate_gpu_malloc(&self, size: usize) -> Result<usize> {
        // Simulate GPU memory allocation - in real implementation would use CUDA/OpenCL
        static mut NEXT_PTR: usize = 0x1000_0000; // Simulate GPU memory space

        unsafe {
            let ptr = NEXT_PTR;
            NEXT_PTR += size;

            // Check if we exceed simulated GPU memory
            if NEXT_PTR > 0x1000_0000 + self.config.max_pool_size {
                return Err(MetricsError::ComputationError(
                    "GPU memory exhausted".to_string(),
                ));
            }

            Ok(ptr)
        }
    }

    fn generate_block_id(&self) -> usize {
        use std::sync::atomic::{AtomicUsize, Ordering};
        static NEXT_ID: AtomicUsize = AtomicUsize::new(1);
        NEXT_ID.fetch_add(1, Ordering::Relaxed)
    }

    fn record_allocation(&self, block: &MemoryBlock) -> Result<()> {
        // Record in allocated blocks
        {
            let mut allocated = self.allocated_blocks.write().expect("Operation failed");
            allocated.insert(
                block.id,
                AllocatedBlock {
                    block: block.clone(),
                    allocated_at: Instant::now(),
                    expected_lifetime: None,
                    usage_pattern: UsagePattern::Sequential, // Could be analyzed
                },
            );
        }

        // Update statistics
        {
            let mut stats = self.stats.lock().expect("Operation failed");
            stats.allocation_count += 1;
            stats.total_allocated += block.size;
            if stats.total_allocated > stats.peak_usage {
                stats.peak_usage = stats.total_allocated;
            }

            // Update average allocation size
            stats.avg_allocation_size =
                stats.total_allocated as f64 / stats.allocation_count as f64;
        }

        Ok(())
    }

    fn update_prefetcher(&self, block: &MemoryBlock) {
        // Record this allocation in the prefetcher's history so that pattern
        // analysis has data to work with.
        self.prefetcher.record_allocation(AllocationRecord {
            size: block.size,
            blocktype: block.blocktype.clone(),
            timestamp: Instant::now(),
            lifetime: None,
        });
    }

    fn coalesce_and_return(&self, block: MemoryBlock) -> Result<()> {
        // Try to coalesce with adjacent free blocks
        // Simplified implementation - in practice would need more sophisticated buddy tracking
        self.return_to_pool(block)
    }

    fn return_to_pool(&self, block: MemoryBlock) -> Result<()> {
        let mut free_blocks = self.free_blocks.lock().expect("Operation failed");
        free_blocks
            .entry(block.size)
            .or_insert_with(VecDeque::new)
            .push_back(block);
        Ok(())
    }

    fn should_run_gc(&self) -> Result<bool> {
        let stats = self.stats.lock().expect("Operation failed");
        let usage_ratio = stats.total_allocated as f64 / self.config.max_pool_size as f64;
        Ok(usage_ratio > self.config.gc_threshold)
    }

    fn run_garbage_collection(&self) -> Result<()> {
        // Implement garbage collection logic
        // - Remove unused blocks
        // - Coalesce adjacent free blocks
        // - Update fragmentation statistics

        let mut stats = self.stats.lock().expect("Operation failed");
        stats.fragmentation_ratio = self.calculate_fragmentation()?;
        stats.efficiency_score = self.calculate_efficiency()?;

        Ok(())
    }

    fn calculate_fragmentation(&self) -> Result<f64> {
        // Calculate memory fragmentation ratio
        // Simplified calculation - real implementation would be more sophisticated
        Ok(0.1) // 10% fragmentation as example
    }

    fn calculate_efficiency(&self) -> Result<f64> {
        // Calculate memory utilization efficiency
        let stats = self.stats.lock().expect("Operation failed");
        if stats.peak_usage == 0 {
            Ok(1.0)
        } else {
            Ok(stats.total_allocated as f64 / stats.peak_usage as f64)
        }
    }

    fn analyze_allocation_patterns(&self) -> Result<Vec<AllocationPattern>> {
        let history = self.prefetcher.allocation_history.lock().map_err(|_| {
            MetricsError::ComputationError("failed to acquire prefetcher history lock".to_string())
        })?;

        if history.is_empty() {
            return Ok(vec![]);
        }

        // Group allocations by size bucket (nearest power-of-two kilobyte).
        // Each bucket becomes one AllocationPattern whose `signature` is the
        // sorted list of observed sizes within that bucket.
        let mut buckets: HashMap<usize, Vec<AllocationRecord>> = HashMap::new();
        for record in history.iter() {
            // Bucket key = next power-of-two of (size / 1024) rounded up.
            let bucket_kib = (record.size.max(1) + 1023) / 1024;
            let bucket_key = bucket_kib.next_power_of_two().max(1);
            buckets
                .entry(bucket_key)
                .or_insert_with(Vec::new)
                .push(record.clone());
        }

        let total = history.len() as f64;
        let mut patterns: Vec<AllocationPattern> = buckets
            .into_iter()
            .map(|(bucket_key, records)| {
                let frequency = records.len() as u32;
                // Collect distinct sizes in this bucket for the signature.
                let mut sizes: Vec<usize> = records.iter().map(|r| r.size).collect();
                sizes.sort_unstable();
                sizes.dedup();

                // Collect distinct block types.
                let mut block_types: Vec<BlockType> =
                    records.iter().map(|r| r.blocktype.clone()).collect();
                block_types.sort_by_key(|bt| format!("{:?}", bt));
                block_types.dedup_by_key(|bt| format!("{:?}", bt));

                // Accuracy: fraction of all allocations that fall in this bucket
                // (i.e. how well this single pattern describes the workload).
                let accuracy = frequency as f64 / total;

                AllocationPattern {
                    // Signature = [bucket_key_kib] ++ sorted unique sizes
                    signature: std::iter::once(bucket_key).chain(sizes).collect(),
                    frequency,
                    accuracy,
                    block_types,
                }
            })
            .collect();

        // Most frequent patterns first.
        patterns.sort_by(|a, b| b.frequency.cmp(&a.frequency));

        Ok(patterns)
    }

    fn suggest_optimizations(
        &self,
        patterns: &[AllocationPattern],
    ) -> Result<Vec<OptimizationType>> {
        if patterns.is_empty() {
            return Ok(vec![]);
        }

        let mut suggestions: Vec<OptimizationType> = Vec::new();

        // Heuristic 1: many small allocations (bucket ≤ 4 KiB, high frequency)
        // → pooling / coalescing will reduce per-allocation overhead.
        let small_alloc_count: u32 = patterns
            .iter()
            .filter(|p| p.signature.first().copied().unwrap_or(0) <= 4)
            .map(|p| p.frequency)
            .sum();
        let total_count: u32 = patterns.iter().map(|p| p.frequency).sum();
        if total_count > 0 && small_alloc_count * 2 > total_count {
            suggestions.push(OptimizationType::MemoryCoalescing);
        }

        // Heuristic 2: many distinct size classes (> 4 patterns) → fragmentation
        // risk; reordering blocks by size can improve contiguity.
        if patterns.len() > 4 {
            suggestions.push(OptimizationType::BlockReordering);
        }

        // Heuristic 3: single dominant pattern with high accuracy (> 60 %) →
        // prefetch is likely to be profitable.
        if patterns.first().map(|p| p.accuracy > 0.6).unwrap_or(false) {
            suggestions.push(OptimizationType::PrefetchOptimization);
        }

        // Heuristic 4: high diversity (accuracy of best pattern < 25 %) →
        // current fixed strategy is not well-matched; switch to Adaptive.
        if patterns.first().map(|p| p.accuracy < 0.25).unwrap_or(false) {
            suggestions.push(OptimizationType::AllocationStrategyChange);
        }

        Ok(suggestions)
    }

    fn apply_optimization(&self, optimization: OptimizationType) -> Result<()> {
        // Apply specific optimization
        Ok(())
    }

    fn benchmark_strategy(
        &self,
        strategy: &AllocationStrategy,
        workload: &[AllocationRequest],
    ) -> Result<StrategyMetrics> {
        // Benchmark specific allocation strategy
        Ok(StrategyMetrics::default())
    }
}

impl MemoryPrefetcher {
    fn new(config: PrefetchConfig) -> Self {
        Self {
            allocation_history: Arc::new(Mutex::new(VecDeque::new())),
            predictions: Vec::new(),
            pattern_engine: PatternEngine {
                patterns: Vec::new(),
                accuracy: 0.0,
                training_samples: 0,
            },
            config,
        }
    }

    /// Record an allocation event in the history ring-buffer.
    ///
    /// The history is capped at the configured `history_window` size so that
    /// memory usage remains bounded even under long-running workloads.
    fn record_allocation(&self, record: AllocationRecord) {
        let window = self.config.buffer_size_limit.max(1);
        if let Ok(mut hist) = self.allocation_history.lock() {
            if hist.len() >= window {
                hist.pop_front();
            }
            hist.push_back(record);
        }
    }

    fn get_predicted_block(
        &self,
        size: usize,
        blocktype: &BlockType,
    ) -> Result<Option<MemoryBlock>> {
        // Check if we have a predicted block ready
        // Implementation would check predictions and return suitable block
        let _ = (size, blocktype);
        Ok(None)
    }
}

/// Optimization type enum
#[derive(Debug, Clone)]
pub enum OptimizationType {
    MemoryCoalescing,
    BlockReordering,
    PrefetchOptimization,
    AllocationStrategyChange,
}

/// Allocation request for benchmarking
#[derive(Debug, Clone)]
pub struct AllocationRequest {
    pub size: usize,
    pub blocktype: BlockType,
    pub lifetime: Duration,
}

/// Strategy benchmark results
#[derive(Debug)]
pub struct StrategyBenchmark {
    pub results: HashMap<String, StrategyMetrics>,
}

/// Strategy performance metrics
#[derive(Debug, Default)]
pub struct StrategyMetrics {
    pub allocation_speed: f64,
    pub fragmentation_ratio: f64,
    pub memory_efficiency: f64,
    pub cache_hit_rate: f64,
}

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

    #[test]
    fn test_memory_pool_creation() {
        let config = MemoryPoolConfig::default();
        let pool = AdvancedMemoryPool::new(config);

        let stats = pool.get_stats();
        assert_eq!(stats.total_allocated, 0);
        assert_eq!(stats.allocation_count, 0);
    }

    #[test]
    fn test_basic_allocation() {
        let pool = AdvancedMemoryPool::new(MemoryPoolConfig::default());

        let block = pool
            .allocate(1024, BlockType::InputData)
            .expect("Operation failed");
        assert_eq!(block.size, 1024);
        assert_eq!(block.blocktype, BlockType::InputData);

        let stats = pool.get_stats();
        assert_eq!(stats.allocation_count, 1);
        assert!(stats.total_allocated >= 1024);
    }

    #[test]
    fn test_allocation_deallocation_cycle() {
        let pool = AdvancedMemoryPool::new(MemoryPoolConfig::default());

        let block = pool
            .allocate(2048, BlockType::OutputData)
            .expect("Operation failed");
        let _block_id = block.id;

        pool.deallocate(block).expect("Operation failed");

        let stats = pool.get_stats();
        assert_eq!(stats.deallocation_count, 1);
    }

    #[test]
    fn test_memory_alignment() {
        let config = MemoryPoolConfig {
            alignment: 512,
            ..Default::default()
        };
        let pool = AdvancedMemoryPool::new(config);

        // Test that allocations are properly aligned
        let block = pool
            .allocate(100, BlockType::IntermediateBuffer)
            .expect("Operation failed");
        assert_eq!(block.size % 512, 0);
    }

    #[test]
    fn test_strategy_benchmarking() {
        let pool = AdvancedMemoryPool::new(MemoryPoolConfig::default());

        let workload = vec![
            AllocationRequest {
                size: 1024,
                blocktype: BlockType::InputData,
                lifetime: Duration::from_millis(100),
            },
            AllocationRequest {
                size: 2048,
                blocktype: BlockType::OutputData,
                lifetime: Duration::from_millis(200),
            },
        ];

        let benchmark = pool
            .benchmark_strategies(&workload)
            .expect("Operation failed");
        assert!(!benchmark.results.is_empty());
    }

    // --- pattern analysis and optimization suggestion tests ---

    /// Allocate several blocks then verify `analyze_allocation_patterns` returns
    /// at least one pattern with a non-zero frequency.
    #[test]
    fn test_analyze_allocation_patterns_non_empty_after_allocations() {
        let pool = AdvancedMemoryPool::new(MemoryPoolConfig::default());

        // Make ten small allocations (all same size → single bucket)
        for _ in 0..10 {
            pool.allocate(512, BlockType::IntermediateBuffer)
                .expect("allocation must succeed");
        }

        let patterns = pool
            .analyze_allocation_patterns()
            .expect("analyze_allocation_patterns must not fail");

        assert!(
            !patterns.is_empty(),
            "must return at least one pattern after allocations"
        );
        assert!(
            patterns[0].frequency > 0,
            "dominant pattern must have non-zero frequency"
        );
    }

    /// After uniform-size allocations the dominant pattern should have high
    /// accuracy (close to 1.0) and `suggest_optimizations` should fire at
    /// least one suggestion.
    #[test]
    fn test_suggest_optimizations_after_uniform_allocations() {
        let pool = AdvancedMemoryPool::new(MemoryPoolConfig::default());

        for _ in 0..20 {
            pool.allocate(256, BlockType::InputData)
                .expect("allocation must succeed");
        }

        let patterns = pool
            .analyze_allocation_patterns()
            .expect("analyze_allocation_patterns must not fail");
        assert!(!patterns.is_empty(), "patterns must be non-empty");

        let suggestions = pool
            .suggest_optimizations(&patterns)
            .expect("suggest_optimizations must not fail");
        assert!(
            !suggestions.is_empty(),
            "at least one optimization should be suggested for a uniform workload"
        );
    }

    /// With a mixed workload (many different sizes) the analysis should produce
    /// multiple patterns and the `BlockReordering` suggestion should appear.
    #[test]
    fn test_suggest_optimizations_block_reordering_for_diverse_sizes() {
        let pool = AdvancedMemoryPool::new(MemoryPoolConfig::default());

        // Allocate across > 4 distinct size classes
        for size in &[128usize, 512, 1024, 4096, 8192, 16384, 32768] {
            for _ in 0..3 {
                pool.allocate(*size, BlockType::IntermediateBuffer)
                    .expect("allocation must succeed");
            }
        }

        let patterns = pool
            .analyze_allocation_patterns()
            .expect("analyze_allocation_patterns must not fail");
        assert!(
            patterns.len() > 4,
            "diverse workload must produce > 4 patterns"
        );

        let suggestions = pool
            .suggest_optimizations(&patterns)
            .expect("suggest_optimizations must not fail");
        let has_reordering = suggestions
            .iter()
            .any(|s| matches!(s, OptimizationType::BlockReordering));
        assert!(
            has_reordering,
            "BlockReordering should be suggested for a highly diverse workload"
        );
    }
}