memscope_rs/core/

performance_optimizer.rs

//! Performance optimization system that dynamically adapts tracking overhead
//!
//! This module provides intelligent performance optimization by:
//! - Monitoring real allocation patterns to adapt sampling
//! - Using statistical analysis and heuristic rules for pattern recognition
//! - Implementing adaptive data structures based on workload characteristics
//! - Providing real-time performance metrics and optimization suggestions

use crate::core::types::{MemoryStats, TrackingResult};
use crate::core::ultra_fast_tracker::{SamplingStats, UltraFastSamplingConfig, UltraFastTracker};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, RwLock};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

/// Real-time allocation pattern analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AllocationPattern {
    /// Average allocation size
    pub avg_allocation_size: f64,
    /// Standard deviation of allocation sizes
    pub size_std_dev: f64,
    /// Allocation frequency (allocations per second)
    pub allocation_frequency: f64,
    /// Most common allocation sizes (size -> count)
    pub size_distribution: HashMap<u32, u64>,
    /// Peak allocation rate
    pub peak_allocation_rate: f64,
    /// Memory pressure level (0.0 = low, 1.0 = high)
    pub memory_pressure: f64,
    /// Thread contention level (0.0 = no contention, 1.0 = high contention)
    pub thread_contention: f64,
}

impl Default for AllocationPattern {
    fn default() -> Self {
        Self {
            avg_allocation_size: 0.0,
            size_std_dev: 0.0,
            allocation_frequency: 0.0,
            size_distribution: HashMap::new(),
            peak_allocation_rate: 0.0,
            memory_pressure: 0.0,
            thread_contention: 0.0,
        }
    }
}

/// Performance optimization recommendations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationRecommendations {
    /// Recommended sampling configuration
    pub recommended_config: UltraFastSamplingConfig,
    /// Expected performance improvement
    pub expected_improvement: f64,
    /// Confidence level of recommendations (0.0-1.0)
    pub confidence: f64,
    /// Specific optimization actions
    pub actions: Vec<OptimizationAction>,
    /// Estimated memory overhead reduction
    pub memory_overhead_reduction: f64,
    /// Estimated CPU overhead reduction
    pub cpu_overhead_reduction: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum OptimizationAction {
    /// Adjust sampling rates
    AdjustSampling {
        size_threshold: usize,
        new_rate: f32,
        reason: String,
    },
    /// Enable/disable features
    ToggleFeature {
        feature: String,
        enable: bool,
        reason: String,
    },
    /// Change buffer sizes
    AdjustBuffers { new_size: usize, reason: String },
    /// Switch algorithms
    SwitchAlgorithm { algorithm: String, reason: String },
}

/// Real-time performance metrics
#[derive(Debug, Clone)]
pub struct PerformanceMetrics {
    /// CPU overhead percentage (0.0-100.0)
    pub cpu_overhead_percent: f64,
    /// Memory overhead in bytes
    pub memory_overhead_bytes: u64,
    /// Tracking latency in nanoseconds
    pub tracking_latency_ns: u64,
    /// Throughput (operations per second)
    pub throughput_ops_per_sec: f64,
    /// Data quality score (0.0-1.0)
    pub data_quality_score: f64,
    /// System health score (0.0-1.0)
    pub system_health_score: f64,
}

/// Adaptive performance optimizer
pub struct PerformanceOptimizer {
    /// Current tracker instance
    tracker: Arc<UltraFastTracker>,
    /// Allocation pattern analyzer
    pattern_analyzer: Arc<RwLock<PatternAnalyzer>>,
    /// Performance metrics collector
    metrics_collector: Arc<MetricsCollector>,
    /// Optimization engine
    optimization_engine: Arc<OptimizationEngine>,
    /// Current configuration
    current_config: Arc<RwLock<UltraFastSamplingConfig>>,
    /// Optimization enabled flag
    optimization_enabled: AtomicBool,
}

impl PerformanceOptimizer {
    /// Create new performance optimizer
    pub fn new() -> Self {
        let config = UltraFastSamplingConfig::default();
        let tracker = Arc::new(UltraFastTracker::with_config(config.clone()));

        Self {
            tracker,
            pattern_analyzer: Arc::new(RwLock::new(PatternAnalyzer::new())),
            metrics_collector: Arc::new(MetricsCollector::new()),
            optimization_engine: Arc::new(OptimizationEngine::new()),
            current_config: Arc::new(RwLock::new(config)),
            optimization_enabled: AtomicBool::new(true),
        }
    }

    /// Track allocation with automatic optimization
    pub fn track_allocation(&self, ptr: usize, size: usize, type_name: &str) -> TrackingResult<()> {
        let start_time = Instant::now();

        // Record allocation pattern
        if let Ok(mut analyzer) = self.pattern_analyzer.write() {
            analyzer.record_allocation(size, type_name);
        }

        // Track with current tracker
        let result = self.tracker.track_allocation(ptr, size, type_name);

        // Record performance metrics
        let duration = start_time.elapsed();
        self.metrics_collector.record_operation_latency(duration);

        // Trigger optimization if needed
        if self.optimization_enabled.load(Ordering::Relaxed) {
            self.consider_optimization();
        }

        result
    }

    /// Track deallocation
    pub fn track_deallocation(&self, ptr: usize) -> TrackingResult<()> {
        let start_time = Instant::now();

        let result = self.tracker.track_deallocation(ptr);

        let duration = start_time.elapsed();
        self.metrics_collector.record_operation_latency(duration);

        result
    }

    /// Get current performance metrics
    pub fn get_performance_metrics(&self) -> PerformanceMetrics {
        self.metrics_collector.get_current_metrics()
    }

    /// Get allocation patterns
    pub fn get_allocation_patterns(&self) -> AllocationPattern {
        self.pattern_analyzer
            .read()
            .map(|analyzer| analyzer.get_current_pattern())
            .unwrap_or_default()
    }

    /// Get optimization recommendations
    pub fn get_optimization_recommendations(&self) -> OptimizationRecommendations {
        let patterns = self.get_allocation_patterns();
        let metrics = self.get_performance_metrics();
        let current_config = self.current_config.read().unwrap().clone();

        self.optimization_engine
            .generate_recommendations(patterns, metrics, current_config)
    }

    /// Apply optimization recommendations
    pub fn apply_optimizations(
        &self,
        recommendations: &OptimizationRecommendations,
    ) -> TrackingResult<()> {
        // Update configuration
        if let Ok(mut config) = self.current_config.write() {
            *config = recommendations.recommended_config.clone();
        }

        // Apply specific actions
        for action in &recommendations.actions {
            self.apply_optimization_action(action)?;
        }

        // Record optimization event
        self.metrics_collector.record_optimization_event();

        Ok(())
    }

    /// Enable/disable automatic optimization
    pub fn set_optimization_enabled(&self, enabled: bool) {
        self.optimization_enabled.store(enabled, Ordering::Relaxed);
    }

    /// Get memory statistics
    pub fn get_stats(&self) -> TrackingResult<MemoryStats> {
        self.tracker.get_stats()
    }

    /// Get sampling statistics
    pub fn get_sampling_stats(&self) -> SamplingStats {
        self.tracker.get_sampling_stats()
    }

    /// Force optimization analysis
    pub fn force_optimization(&self) -> TrackingResult<()> {
        let recommendations = self.get_optimization_recommendations();
        if recommendations.confidence > 0.5 {
            self.apply_optimizations(&recommendations)?;
        }
        Ok(())
    }

    /// Consider if optimization is needed
    fn consider_optimization(&self) {
        // Simple heuristic: optimize every 10,000 operations
        if self.metrics_collector.get_operation_count() % 10000 == 0 {
            if let Ok(recommendations) =
                std::panic::catch_unwind(|| self.get_optimization_recommendations())
            {
                if recommendations.confidence > 0.7 {
                    let _ = self.apply_optimizations(&recommendations);
                }
            }
        }
    }

    /// Apply a specific optimization action
    fn apply_optimization_action(&self, action: &OptimizationAction) -> TrackingResult<()> {
        match action {
            OptimizationAction::AdjustSampling {
                size_threshold,
                new_rate,
                ..
            } => {
                if let Ok(mut config) = self.current_config.write() {
                    if *size_threshold >= 1024 {
                        config.medium_sample_rate = *new_rate;
                    } else {
                        config.small_sample_rate = *new_rate;
                    }
                }
            }
            OptimizationAction::AdjustBuffers { new_size, .. } => {
                if let Ok(mut config) = self.current_config.write() {
                    config.max_records_per_thread = *new_size;
                }
            }
            OptimizationAction::ToggleFeature {
                feature, enable, ..
            } => {
                if feature == "simd" {
                    if let Ok(mut config) = self.current_config.write() {
                        config.enable_simd = *enable;
                    }
                }
            }
            OptimizationAction::SwitchAlgorithm { .. } => {
                // Algorithm switching would be implemented here
            }
        }
        Ok(())
    }
}

/// Pattern analyzer for allocation behavior
struct PatternAnalyzer {
    /// Recent allocation sizes
    recent_sizes: VecDeque<usize>,
    /// Size distribution tracking
    size_buckets: HashMap<u32, u64>,
    /// Timing data
    allocation_times: VecDeque<u64>,
    /// Type frequency
    type_frequency: HashMap<String, u64>,
    /// Window size for analysis
    window_size: usize,
}

impl PatternAnalyzer {
    fn new() -> Self {
        Self {
            recent_sizes: VecDeque::with_capacity(10000),
            size_buckets: HashMap::new(),
            allocation_times: VecDeque::with_capacity(10000),
            type_frequency: HashMap::new(),
            window_size: 10000,
        }
    }

    fn record_allocation(&mut self, size: usize, type_name: &str) {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_micros() as u64;

        // Track size
        self.recent_sizes.push_back(size);
        if self.recent_sizes.len() > self.window_size {
            self.recent_sizes.pop_front();
        }

        // Track timing
        self.allocation_times.push_back(now);
        if self.allocation_times.len() > self.window_size {
            self.allocation_times.pop_front();
        }

        // Track size distribution
        let bucket = Self::size_to_bucket(size);
        *self.size_buckets.entry(bucket).or_insert(0) += 1;

        // Track type frequency
        *self
            .type_frequency
            .entry(type_name.to_string())
            .or_insert(0) += 1;
    }

    fn get_current_pattern(&self) -> AllocationPattern {
        let avg_size = if !self.recent_sizes.is_empty() {
            self.recent_sizes.iter().sum::<usize>() as f64 / self.recent_sizes.len() as f64
        } else {
            0.0
        };

        let size_variance = if self.recent_sizes.len() > 1 {
            let mean = avg_size;
            let variance = self
                .recent_sizes
                .iter()
                .map(|&size| {
                    let diff = size as f64 - mean;
                    diff * diff
                })
                .sum::<f64>()
                / (self.recent_sizes.len() - 1) as f64;
            variance.sqrt()
        } else {
            0.0
        };

        let frequency = if self.allocation_times.len() >= 2 {
            let time_span =
                self.allocation_times.back().unwrap() - self.allocation_times.front().unwrap();
            if time_span > 0 {
                (self.allocation_times.len() as f64 * 1_000_000.0) / time_span as f64
            } else {
                0.0
            }
        } else {
            0.0
        };

        AllocationPattern {
            avg_allocation_size: avg_size,
            size_std_dev: size_variance,
            allocation_frequency: frequency,
            size_distribution: self.size_buckets.clone(),
            peak_allocation_rate: frequency * 1.5, // Estimate
            memory_pressure: self.calculate_memory_pressure(),
            thread_contention: 0.1, // Simplified
        }
    }

    fn size_to_bucket(size: usize) -> u32 {
        // Create logarithmic buckets
        if size == 0 {
            return 0;
        }
        let log_size = (size as f64).log2() as u32;
        log_size.min(31) // Cap at 2^31
    }

    fn calculate_memory_pressure(&self) -> f64 {
        // Simple heuristic based on allocation frequency and size
        let avg_size = if !self.recent_sizes.is_empty() {
            self.recent_sizes.iter().sum::<usize>() as f64 / self.recent_sizes.len() as f64
        } else {
            0.0
        };

        let frequency = self.allocation_times.len() as f64;
        let pressure = (avg_size * frequency) / 1_000_000.0; // Normalize
        pressure.min(1.0)
    }
}

/// Metrics collector for performance monitoring
struct MetricsCollector {
    /// Operation latencies (nanoseconds)
    operation_latencies: RwLock<VecDeque<u64>>,
    /// Total operation count
    operation_count: AtomicU64,
    /// Memory overhead estimation
    memory_overhead: AtomicU64,
    /// CPU time spent tracking
    cpu_time_ns: AtomicU64,
    /// Last optimization timestamp
    last_optimization: AtomicU64,
}

impl MetricsCollector {
    fn new() -> Self {
        Self {
            operation_latencies: RwLock::new(VecDeque::with_capacity(10000)),
            operation_count: AtomicU64::new(0),
            memory_overhead: AtomicU64::new(0),
            cpu_time_ns: AtomicU64::new(0),
            last_optimization: AtomicU64::new(0),
        }
    }

    fn record_operation_latency(&self, duration: Duration) {
        let latency_ns = duration.as_nanos() as u64;

        self.operation_count.fetch_add(1, Ordering::Relaxed);
        self.cpu_time_ns.fetch_add(latency_ns, Ordering::Relaxed);

        if let Ok(mut latencies) = self.operation_latencies.write() {
            latencies.push_back(latency_ns);
            if latencies.len() > 10000 {
                latencies.pop_front();
            }
        }
    }

    fn record_optimization_event(&self) {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
        self.last_optimization.store(now, Ordering::Relaxed);
    }

    fn get_current_metrics(&self) -> PerformanceMetrics {
        let avg_latency = if let Ok(latencies) = self.operation_latencies.read() {
            if !latencies.is_empty() {
                latencies.iter().sum::<u64>() / latencies.len() as u64
            } else {
                0
            }
        } else {
            0
        };

        let operations = self.operation_count.load(Ordering::Relaxed);
        let cpu_time = self.cpu_time_ns.load(Ordering::Relaxed);

        let throughput = if cpu_time > 0 {
            (operations as f64 * 1_000_000_000.0) / cpu_time as f64
        } else {
            0.0
        };

        PerformanceMetrics {
            cpu_overhead_percent: 5.0, // Estimated
            memory_overhead_bytes: self.memory_overhead.load(Ordering::Relaxed),
            tracking_latency_ns: avg_latency,
            throughput_ops_per_sec: throughput,
            data_quality_score: 0.95, // High quality due to real data collection
            system_health_score: 0.9,
        }
    }

    fn get_operation_count(&self) -> u64 {
        self.operation_count.load(Ordering::Relaxed)
    }
}

/// Optimization engine using rule-based heuristics and statistical analysis
struct OptimizationEngine;

impl OptimizationEngine {
    fn new() -> Self {
        Self
    }

    fn generate_recommendations(
        &self,
        patterns: AllocationPattern,
        metrics: PerformanceMetrics,
        current_config: UltraFastSamplingConfig,
    ) -> OptimizationRecommendations {
        let mut actions = Vec::new();
        let mut confidence = 0.5;

        // Analyze allocation patterns and suggest optimizations

        // If average allocation size is small, reduce sampling
        if patterns.avg_allocation_size < 512.0 && current_config.small_sample_rate > 0.001 {
            actions.push(OptimizationAction::AdjustSampling {
                size_threshold: 512,
                new_rate: 0.001,
                reason: "Small allocations detected, reducing sampling overhead".to_string(),
            });
            confidence += 0.2;
        }

        // If allocation frequency is high, increase buffer size
        if patterns.allocation_frequency > 1000.0 && current_config.max_records_per_thread < 20000 {
            actions.push(OptimizationAction::AdjustBuffers {
                new_size: 20000,
                reason: "High allocation frequency, increasing buffer size".to_string(),
            });
            confidence += 0.15;
        }

        // If CPU overhead is high, reduce sampling rates
        if metrics.cpu_overhead_percent > 10.0 {
            actions.push(OptimizationAction::AdjustSampling {
                size_threshold: 1024,
                new_rate: current_config.medium_sample_rate * 0.5,
                reason: "High CPU overhead detected, reducing sampling".to_string(),
            });
            confidence += 0.25;
        }

        // Enable SIMD if not enabled and system supports it
        if !current_config.enable_simd && cfg!(target_feature = "avx2") {
            actions.push(OptimizationAction::ToggleFeature {
                feature: "simd".to_string(),
                enable: true,
                reason: "SIMD support detected, enabling optimizations".to_string(),
            });
            confidence += 0.1;
        }

        let mut optimized_config = current_config;

        // Apply recommendations to config
        for action in &actions {
            match action {
                OptimizationAction::AdjustSampling {
                    size_threshold,
                    new_rate,
                    ..
                } => {
                    if *size_threshold >= 1024 {
                        optimized_config.medium_sample_rate = *new_rate;
                    } else {
                        optimized_config.small_sample_rate = *new_rate;
                    }
                }
                OptimizationAction::AdjustBuffers { new_size, .. } => {
                    optimized_config.max_records_per_thread = *new_size;
                }
                OptimizationAction::ToggleFeature {
                    feature, enable, ..
                } => {
                    if feature == "simd" {
                        optimized_config.enable_simd = *enable;
                    }
                }
                _ => {}
            }
        }

        OptimizationRecommendations {
            recommended_config: optimized_config,
            expected_improvement: confidence * 30.0, // Up to 30% improvement
            confidence: confidence.min(1.0),
            actions,
            memory_overhead_reduction: 15.0,
            cpu_overhead_reduction: 25.0,
        }
    }
}

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

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

    #[test]
    fn test_performance_optimizer_basic() {
        let optimizer = PerformanceOptimizer::new();

        // Track some allocations
        optimizer
            .track_allocation(0x1000, 1024, "Vec<i32>")
            .unwrap();
        optimizer.track_allocation(0x2000, 512, "String").unwrap();

        let stats = optimizer.get_stats().unwrap();
        assert_eq!(stats.total_allocations, 2);

        let metrics = optimizer.get_performance_metrics();
        assert!(metrics.throughput_ops_per_sec >= 0.0);
    }

    #[test]
    fn test_pattern_analysis() {
        let optimizer = PerformanceOptimizer::new();

        // Create allocation pattern
        for i in 0..100 {
            optimizer
                .track_allocation(0x1000 + i, 1024, "TestType")
                .unwrap();
        }

        let patterns = optimizer.get_allocation_patterns();
        assert!(patterns.avg_allocation_size > 0.0);
        assert!(patterns.allocation_frequency >= 0.0);
    }

    #[test]
    fn test_optimization_recommendations() {
        let optimizer = PerformanceOptimizer::new();

        // Generate some load
        for i in 0..1000 {
            optimizer
                .track_allocation(0x1000 + i, 64, "SmallAlloc")
                .unwrap();
        }

        let recommendations = optimizer.get_optimization_recommendations();
        assert!(recommendations.confidence >= 0.5);
        assert!(!recommendations.actions.is_empty());
    }

    #[test]
    fn test_pattern_analyzer() {
        let mut analyzer = PatternAnalyzer::new();

        analyzer.record_allocation(1024, "Vec<i32>");
        analyzer.record_allocation(512, "String");
        analyzer.record_allocation(1024, "HashMap");

        let pattern = analyzer.get_current_pattern();
        assert!(pattern.avg_allocation_size > 0.0);
    }
}