memscope_rs/platform/

memory_info.rs

use std::time::{Duration, Instant};

/// Platform-specific memory information collector
pub struct PlatformMemoryInfo {
    /// Last collected statistics
    last_stats: Option<MemoryStats>,
    /// Collection interval
    collection_interval: Duration,
    /// Last collection time
    last_collection: Option<Instant>,
    /// Platform-specific context
    platform_context: MemoryContext,
}

/// Comprehensive memory statistics
#[derive(Debug, Clone)]
pub struct MemoryStats {
    /// Virtual memory statistics
    pub virtual_memory: VirtualMemoryStats,
    /// Physical memory statistics
    pub physical_memory: PhysicalMemoryStats,
    /// Process-specific memory statistics
    pub process_memory: ProcessMemoryStats,
    /// System-wide memory statistics
    pub system_memory: SystemMemoryStats,
    /// Memory pressure indicators
    pub pressure_indicators: PressureIndicators,
    /// Collection timestamp
    pub timestamp: Instant,
}

/// Virtual memory statistics
#[derive(Debug, Clone)]
pub struct VirtualMemoryStats {
    /// Total virtual address space
    pub total_virtual: u64,
    /// Available virtual address space
    pub available_virtual: u64,
    /// Used virtual address space
    pub used_virtual: u64,
    /// Reserved but uncommitted memory
    pub reserved: u64,
    /// Committed memory
    pub committed: u64,
}

/// Physical memory statistics
#[derive(Debug, Clone)]
pub struct PhysicalMemoryStats {
    /// Total physical memory (RAM)
    pub total_physical: u64,
    /// Available physical memory
    pub available_physical: u64,
    /// Used physical memory
    pub used_physical: u64,
    /// Memory used by OS cache
    pub cached: u64,
    /// Memory used by OS buffers
    pub buffers: u64,
    /// Swap/page file statistics
    pub swap: SwapStats,
}

/// Swap/page file statistics
#[derive(Debug, Clone)]
pub struct SwapStats {
    /// Total swap/page file size
    pub total_swap: u64,
    /// Used swap/page file
    pub used_swap: u64,
    /// Available swap/page file
    pub available_swap: u64,
    /// Swap-in rate (pages per second)
    pub swap_in_rate: f64,
    /// Swap-out rate (pages per second)
    pub swap_out_rate: f64,
}

/// Process-specific memory statistics
#[derive(Debug, Clone)]
pub struct ProcessMemoryStats {
    /// Process virtual memory size
    pub virtual_size: u64,
    /// Process resident set size (RSS)
    pub resident_size: u64,
    /// Process shared memory
    pub shared_size: u64,
    /// Process private memory
    pub private_size: u64,
    /// Heap memory usage
    pub heap_size: u64,
    /// Stack memory usage
    pub stack_size: u64,
    /// Memory-mapped files
    pub mapped_files: u64,
    /// Process memory peak usage
    pub peak_usage: u64,
}

/// System-wide memory statistics
#[derive(Debug, Clone)]
pub struct SystemMemoryStats {
    /// Number of memory allocations
    pub allocation_count: u64,
    /// Number of memory deallocations
    pub deallocation_count: u64,
    /// Current active allocations
    pub active_allocations: u64,
    /// Total bytes allocated
    pub total_allocated: u64,
    /// Total bytes deallocated
    pub total_deallocated: u64,
    /// Memory fragmentation level
    pub fragmentation_level: f64,
    /// Large page usage
    pub large_pages: LargePageStats,
}

/// Large page usage statistics
#[derive(Debug, Clone)]
pub struct LargePageStats {
    /// Whether large pages are supported
    pub supported: bool,
    /// Total large page memory
    pub total_large_pages: u64,
    /// Used large page memory
    pub used_large_pages: u64,
    /// Large page size
    pub page_size: u64,
}

/// Memory pressure indicators
#[derive(Debug, Clone)]
pub struct PressureIndicators {
    /// Overall memory pressure level
    pub pressure_level: PressureLevel,
    /// Whether system is in low memory condition
    pub low_memory: bool,
    /// Whether swapping is occurring
    pub swapping_active: bool,
    /// Memory allocation failure rate
    pub allocation_failure_rate: f64,
    /// GC pressure (if applicable)
    pub gc_pressure: Option<f64>,
}

/// Memory pressure levels
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum PressureLevel {
    /// Normal memory pressure
    Normal,
    /// Moderate memory pressure
    Moderate,
    /// High memory pressure
    High,
    /// Critical memory pressure
    Critical,
}

/// System information
#[derive(Debug, Clone)]
pub struct SystemInfo {
    /// Operating system name
    pub os_name: String,
    /// OS version
    pub os_version: String,
    /// System architecture
    pub architecture: String,
    /// Number of CPU cores
    pub cpu_cores: u32,
    /// CPU cache sizes
    pub cpu_cache: CpuCacheInfo,
    /// Page size
    pub page_size: u64,
    /// Large page size if supported
    pub large_page_size: Option<u64>,
    /// Memory management unit info
    pub mmu_info: MmuInfo,
}

/// CPU cache information
#[derive(Debug, Clone)]
pub struct CpuCacheInfo {
    /// L1 cache size per core
    pub l1_cache_size: u64,
    /// L2 cache size per core
    pub l2_cache_size: u64,
    /// L3 cache size (shared)
    pub l3_cache_size: Option<u64>,
    /// Cache line size
    pub cache_line_size: u64,
}

/// Memory Management Unit information
#[derive(Debug, Clone)]
pub struct MmuInfo {
    /// Virtual address space size (bits)
    pub virtual_address_bits: u32,
    /// Physical address space size (bits)
    pub physical_address_bits: u32,
    /// Whether ASLR is enabled
    pub aslr_enabled: bool,
    /// Whether NX/XD bit is supported
    pub nx_bit_supported: bool,
}

/// Platform-specific context
#[derive(Debug)]
struct MemoryContext {
    /// Whether collector is initialized
    initialized: bool,

    #[cfg(target_os = "linux")]
    linux_context: LinuxMemoryContext,

    #[cfg(target_os = "windows")]
    windows_context: WindowsMemoryContext,

    #[cfg(target_os = "macos")]
    macos_context: MacOSMemoryContext,
}

#[cfg(target_os = "linux")]
#[derive(Debug)]
struct LinuxMemoryContext {
    /// Whether /proc/meminfo is accessible
    proc_meminfo_available: bool,
    /// Whether /proc/self/status is accessible
    proc_status_available: bool,
    /// Whether /proc/self/maps is accessible
    proc_maps_available: bool,
}

#[cfg(target_os = "windows")]
#[derive(Debug)]
struct WindowsMemoryContext {
    /// Whether GlobalMemoryStatusEx is available
    global_memory_api_available: bool,
    /// Whether GetProcessMemoryInfo is available
    process_memory_api_available: bool,
    /// Whether VirtualQueryEx is available
    virtual_query_available: bool,
}

#[cfg(target_os = "macos")]
#[derive(Debug)]
struct MacOSMemoryContext {
    /// Whether vm_stat is available
    vm_stat_available: bool,
    /// Whether task_info is available
    task_info_available: bool,
    /// Whether mach APIs are available
    mach_api_available: bool,
}

impl PlatformMemoryInfo {
    /// Create new memory info collector
    pub fn new() -> Self {
        Self {
            last_stats: None,
            collection_interval: Duration::from_secs(1),
            last_collection: None,
            platform_context: MemoryContext::new(),
        }
    }

    /// Initialize memory info collector
    pub fn initialize(&mut self) -> Result<(), MemoryError> {
        #[cfg(target_os = "linux")]
        {
            self.initialize_linux()
        }

        #[cfg(target_os = "windows")]
        {
            self.initialize_windows()
        }

        #[cfg(target_os = "macos")]
        {
            self.initialize_macos()
        }

        #[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
        {
            Err(MemoryError::UnsupportedPlatform)
        }
    }

    /// Collect current memory statistics
    pub fn collect_stats(&mut self) -> Result<MemoryStats, MemoryError> {
        if !self.platform_context.initialized {
            return Err(MemoryError::NotInitialized);
        }

        let now = Instant::now();

        // Check if we should collect (rate limiting)
        if let Some(last) = self.last_collection {
            if now.duration_since(last) < self.collection_interval {
                if let Some(ref stats) = self.last_stats {
                    return Ok(stats.clone());
                }
            }
        }

        let stats = self.perform_collection()?;
        self.last_stats = Some(stats.clone());
        self.last_collection = Some(now);

        Ok(stats)
    }

    /// Get system information
    pub fn get_system_info(&self) -> Result<SystemInfo, MemoryError> {
        if !self.platform_context.initialized {
            return Err(MemoryError::NotInitialized);
        }

        #[cfg(target_os = "linux")]
        return self.get_linux_system_info();

        #[cfg(target_os = "windows")]
        return self.get_windows_system_info();

        #[cfg(target_os = "macos")]
        return self.get_macos_system_info();

        #[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
        Err(MemoryError::UnsupportedPlatform)
    }

    /// Set collection interval
    pub fn set_collection_interval(&mut self, interval: Duration) {
        self.collection_interval = interval;
    }

    /// Get last collected statistics
    pub fn get_last_stats(&self) -> Option<&MemoryStats> {
        self.last_stats.as_ref()
    }

    fn perform_collection(&self) -> Result<MemoryStats, MemoryError> {
        #[cfg(target_os = "linux")]
        return self.collect_linux_stats();

        #[cfg(target_os = "windows")]
        return self.collect_windows_stats();

        #[cfg(target_os = "macos")]
        return self.collect_macos_stats();

        #[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
        Err(MemoryError::UnsupportedPlatform)
    }

    #[cfg(target_os = "linux")]
    fn initialize_linux(&mut self) -> Result<(), MemoryError> {
        // Check availability of Linux memory information sources
        self.platform_context.linux_context.proc_meminfo_available =
            std::path::Path::new("/proc/meminfo").exists();
        self.platform_context.linux_context.proc_status_available =
            std::path::Path::new("/proc/self/status").exists();
        self.platform_context.linux_context.proc_maps_available =
            std::path::Path::new("/proc/self/maps").exists();

        self.platform_context.initialized = true;
        Ok(())
    }

    #[cfg(target_os = "windows")]
    fn initialize_windows(&mut self) -> Result<(), MemoryError> {
        // Check availability of Windows memory APIs
        self.platform_context
            .windows_context
            .global_memory_api_available = true; // Simplified
        self.platform_context
            .windows_context
            .process_memory_api_available = true; // Simplified
        self.platform_context
            .windows_context
            .virtual_query_available = true; // Simplified

        self.platform_context.initialized = true;
        Ok(())
    }

    #[cfg(target_os = "macos")]
    fn initialize_macos(&mut self) -> Result<(), MemoryError> {
        // Check availability of macOS memory APIs
        self.platform_context.macos_context.vm_stat_available = true; // Simplified
        self.platform_context.macos_context.task_info_available = true; // Simplified
        self.platform_context.macos_context.mach_api_available = true; // Simplified

        self.platform_context.initialized = true;
        Ok(())
    }

    #[cfg(target_os = "linux")]
    fn collect_linux_stats(&self) -> Result<MemoryStats, MemoryError> {
        // Collect Linux memory statistics from /proc filesystem
        // This is a simplified mock implementation
        Ok(MemoryStats {
            virtual_memory: VirtualMemoryStats {
                total_virtual: 1_099_511_627_776,   // 1TB on 64-bit
                available_virtual: 549_755_813_888, // 512GB
                used_virtual: 549_755_813_888,
                reserved: 274_877_906_944, // 256GB
                committed: 274_877_906_944,
            },
            physical_memory: PhysicalMemoryStats {
                total_physical: 17_179_869_184,    // 16GB
                available_physical: 8_589_934_592, // 8GB
                used_physical: 8_589_934_592,
                cached: 4_294_967_296,  // 4GB
                buffers: 1_073_741_824, // 1GB
                swap: SwapStats {
                    total_swap: 8_589_934_592, // 8GB
                    used_swap: 1_073_741_824,  // 1GB
                    available_swap: 7_516_192_768,
                    swap_in_rate: 0.0,
                    swap_out_rate: 0.0,
                },
            },
            process_memory: ProcessMemoryStats {
                virtual_size: 1_073_741_824, // 1GB
                resident_size: 536_870_912,  // 512MB
                shared_size: 134_217_728,    // 128MB
                private_size: 402_653_184,   // 384MB
                heap_size: 268_435_456,      // 256MB
                stack_size: 8_388_608,       // 8MB
                mapped_files: 134_217_728,   // 128MB
                peak_usage: 1_073_741_824,
            },
            system_memory: SystemMemoryStats {
                allocation_count: 1_000_000,
                deallocation_count: 950_000,
                active_allocations: 50_000,
                total_allocated: 10_737_418_240,  // 10GB
                total_deallocated: 9_663_676_416, // 9GB
                fragmentation_level: 0.15,
                large_pages: LargePageStats {
                    supported: true,
                    total_large_pages: 2_097_152, // 2MB
                    used_large_pages: 0,
                    page_size: 2_097_152,
                },
            },
            pressure_indicators: PressureIndicators {
                pressure_level: PressureLevel::Normal,
                low_memory: false,
                swapping_active: false,
                allocation_failure_rate: 0.001,
                gc_pressure: None,
            },
            timestamp: Instant::now(),
        })
    }

    #[cfg(target_os = "windows")]
    fn collect_windows_stats(&self) -> Result<MemoryStats, MemoryError> {
        // Collect Windows memory statistics using Windows APIs
        // This is a simplified mock implementation
        Ok(MemoryStats {
            virtual_memory: VirtualMemoryStats {
                total_virtual: 140_737_488_355_328,    // 128TB on x64
                available_virtual: 70_368_744_177_664, // 64TB
                used_virtual: 70_368_744_177_664,
                reserved: 35_184_372_088_832, // 32TB
                committed: 35_184_372_088_832,
            },
            physical_memory: PhysicalMemoryStats {
                total_physical: 34_359_738_368,     // 32GB
                available_physical: 17_179_869_184, // 16GB
                used_physical: 17_179_869_184,
                cached: 8_589_934_592,  // 8GB
                buffers: 2_147_483_648, // 2GB
                swap: SwapStats {
                    total_swap: 17_179_869_184, // 16GB page file
                    used_swap: 2_147_483_648,   // 2GB
                    available_swap: 15_032_385_536,
                    swap_in_rate: 0.0,
                    swap_out_rate: 0.0,
                },
            },
            process_memory: ProcessMemoryStats {
                virtual_size: 2_147_483_648,  // 2GB
                resident_size: 1_073_741_824, // 1GB
                shared_size: 268_435_456,     // 256MB
                private_size: 805_306_368,    // 768MB
                heap_size: 536_870_912,       // 512MB
                stack_size: 16_777_216,       // 16MB
                mapped_files: 268_435_456,    // 256MB
                peak_usage: 2_147_483_648,
            },
            system_memory: SystemMemoryStats {
                allocation_count: 2_000_000,
                deallocation_count: 1_900_000,
                active_allocations: 100_000,
                total_allocated: 21_474_836_480,   // 20GB
                total_deallocated: 19_327_352_832, // 18GB
                fragmentation_level: 0.12,
                large_pages: LargePageStats {
                    supported: true,
                    total_large_pages: 2_097_152, // 2MB
                    used_large_pages: 0,
                    page_size: 2_097_152,
                },
            },
            pressure_indicators: PressureIndicators {
                pressure_level: PressureLevel::Normal,
                low_memory: false,
                swapping_active: false,
                allocation_failure_rate: 0.0005,
                gc_pressure: None,
            },
            timestamp: Instant::now(),
        })
    }

    #[cfg(target_os = "macos")]
    fn collect_macos_stats(&self) -> Result<MemoryStats, MemoryError> {
        // Collect macOS memory statistics using mach APIs
        // This is a simplified mock implementation
        Ok(MemoryStats {
            virtual_memory: VirtualMemoryStats {
                total_virtual: 1_099_511_627_776,   // 1TB
                available_virtual: 549_755_813_888, // 512GB
                used_virtual: 549_755_813_888,
                reserved: 274_877_906_944, // 256GB
                committed: 274_877_906_944,
            },
            physical_memory: PhysicalMemoryStats {
                total_physical: 68_719_476_736,     // 64GB
                available_physical: 34_359_738_368, // 32GB
                used_physical: 34_359_738_368,
                cached: 17_179_869_184, // 16GB
                buffers: 4_294_967_296, // 4GB
                swap: SwapStats {
                    total_swap: 34_359_738_368, // 32GB
                    used_swap: 4_294_967_296,   // 4GB
                    available_swap: 30_064_771_072,
                    swap_in_rate: 0.0,
                    swap_out_rate: 0.0,
                },
            },
            process_memory: ProcessMemoryStats {
                virtual_size: 4_294_967_296,  // 4GB
                resident_size: 2_147_483_648, // 2GB
                shared_size: 536_870_912,     // 512MB
                private_size: 1_610_612_736,  // 1.5GB
                heap_size: 1_073_741_824,     // 1GB
                stack_size: 33_554_432,       // 32MB
                mapped_files: 536_870_912,    // 512MB
                peak_usage: 4_294_967_296,
            },
            system_memory: SystemMemoryStats {
                allocation_count: 1_500_000,
                deallocation_count: 1_425_000,
                active_allocations: 75_000,
                total_allocated: 16_106_127_360,   // 15GB
                total_deallocated: 14_495_514_624, // 13.5GB
                fragmentation_level: 0.10,
                large_pages: LargePageStats {
                    supported: false,
                    total_large_pages: 0,
                    used_large_pages: 0,
                    page_size: 0,
                },
            },
            pressure_indicators: PressureIndicators {
                pressure_level: PressureLevel::Normal,
                low_memory: false,
                swapping_active: false,
                allocation_failure_rate: 0.0002,
                gc_pressure: None,
            },
            timestamp: Instant::now(),
        })
    }

    #[cfg(target_os = "linux")]
    fn get_linux_system_info(&self) -> Result<SystemInfo, MemoryError> {
        Ok(SystemInfo {
            os_name: "Linux".to_string(),
            os_version: "5.15.0".to_string(),
            architecture: "x86_64".to_string(),
            cpu_cores: 8,
            cpu_cache: CpuCacheInfo {
                l1_cache_size: 32768,         // 32KB
                l2_cache_size: 262144,        // 256KB
                l3_cache_size: Some(8388608), // 8MB
                cache_line_size: 64,
            },
            page_size: 4096,
            large_page_size: Some(2097152), // 2MB
            mmu_info: MmuInfo {
                virtual_address_bits: 48,
                physical_address_bits: 40,
                aslr_enabled: true,
                nx_bit_supported: true,
            },
        })
    }

    #[cfg(target_os = "windows")]
    fn get_windows_system_info(&self) -> Result<SystemInfo, MemoryError> {
        Ok(SystemInfo {
            os_name: "Windows".to_string(),
            os_version: "10.0.19045".to_string(),
            architecture: "x86_64".to_string(),
            cpu_cores: 16,
            cpu_cache: CpuCacheInfo {
                l1_cache_size: 32768,          // 32KB
                l2_cache_size: 524288,         // 512KB
                l3_cache_size: Some(16777216), // 16MB
                cache_line_size: 64,
            },
            page_size: 4096,
            large_page_size: Some(2097152), // 2MB
            mmu_info: MmuInfo {
                virtual_address_bits: 48,
                physical_address_bits: 40,
                aslr_enabled: true,
                nx_bit_supported: true,
            },
        })
    }

    #[cfg(target_os = "macos")]
    fn get_macos_system_info(&self) -> Result<SystemInfo, MemoryError> {
        Ok(SystemInfo {
            os_name: "macOS".to_string(),
            os_version: "14.1.0".to_string(),
            architecture: "arm64".to_string(),
            cpu_cores: 12,
            cpu_cache: CpuCacheInfo {
                l1_cache_size: 65536,   // 64KB
                l2_cache_size: 4194304, // 4MB
                l3_cache_size: None,    // Unified memory architecture
                cache_line_size: 128,
            },
            page_size: 16384,      // 16KB on Apple Silicon
            large_page_size: None, // Not supported on Apple Silicon
            mmu_info: MmuInfo {
                virtual_address_bits: 48,
                physical_address_bits: 40,
                aslr_enabled: true,
                nx_bit_supported: true,
            },
        })
    }
}

impl MemoryContext {
    fn new() -> Self {
        Self {
            initialized: false,
            #[cfg(target_os = "linux")]
            linux_context: LinuxMemoryContext {
                proc_meminfo_available: false,
                proc_status_available: false,
                proc_maps_available: false,
            },
            #[cfg(target_os = "windows")]
            windows_context: WindowsMemoryContext {
                global_memory_api_available: false,
                process_memory_api_available: false,
                virtual_query_available: false,
            },
            #[cfg(target_os = "macos")]
            macos_context: MacOSMemoryContext {
                vm_stat_available: false,
                task_info_available: false,
                mach_api_available: false,
            },
        }
    }
}

/// Errors that can occur during memory information collection
#[derive(Debug, Clone, PartialEq)]
pub enum MemoryError {
    /// Platform not supported
    UnsupportedPlatform,
    /// Collector not initialized
    NotInitialized,
    /// Permission denied
    PermissionDenied,
    /// System API error
    SystemError(String),
    /// Parse error
    ParseError(String),
    /// I/O error
    IoError(String),
}

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

impl std::fmt::Display for MemoryError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MemoryError::UnsupportedPlatform => {
                write!(f, "Platform not supported for memory info collection")
            }
            MemoryError::NotInitialized => write!(f, "Memory info collector not initialized"),
            MemoryError::PermissionDenied => write!(f, "Permission denied for memory info access"),
            MemoryError::SystemError(msg) => write!(f, "System error: {}", msg),
            MemoryError::ParseError(msg) => write!(f, "Parse error: {}", msg),
            MemoryError::IoError(msg) => write!(f, "I/O error: {}", msg),
        }
    }
}

impl std::error::Error for MemoryError {}

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

    #[test]
    fn test_memory_info_creation() {
        let info = PlatformMemoryInfo::new();
        assert!(!info.platform_context.initialized);
        assert!(info.last_stats.is_none());
    }

    #[test]
    fn test_initialization() {
        let mut info = PlatformMemoryInfo::new();
        let result = info.initialize();

        #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
        assert!(result.is_ok());

        #[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
        assert_eq!(result, Err(MemoryError::UnsupportedPlatform));
    }

    #[test]
    fn test_stats_collection() {
        let mut info = PlatformMemoryInfo::new();
        let _ = info.initialize();

        let result = info.collect_stats();

        #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
        {
            if info.platform_context.initialized {
                assert!(result.is_ok());
                let stats = result.expect("Stats should be collected");
                assert!(stats.physical_memory.total_physical > 0);
                assert!(stats.virtual_memory.total_virtual > 0);
            }
        }
    }

    #[test]
    fn test_system_info() {
        let mut info = PlatformMemoryInfo::new();
        let _ = info.initialize();

        let result = info.get_system_info();

        #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
        {
            if info.platform_context.initialized {
                assert!(result.is_ok());
                let sys_info = result.expect("System info should be available");
                assert!(!sys_info.os_name.is_empty());
                assert!(sys_info.cpu_cores > 0);
                assert!(sys_info.page_size > 0);
            }
        }
    }

    #[test]
    fn test_pressure_level_ordering() {
        assert!(PressureLevel::Critical > PressureLevel::High);
        assert!(PressureLevel::High > PressureLevel::Moderate);
        assert!(PressureLevel::Moderate > PressureLevel::Normal);
    }

    #[test]
    fn test_collection_interval() {
        let mut info = PlatformMemoryInfo::new();
        info.set_collection_interval(Duration::from_millis(500));
        assert_eq!(info.collection_interval, Duration::from_millis(500));
    }
}