memscope_rs/lockfree/

tracker.rs

//! Lock-free thread-local memory tracking with intelligent sampling and binary file output.
//!
//! This module implements the multi-threaded approach that eliminates lock contention
//! by using completely independent thread-local tracking with binary file intermediates
//! and intelligent sampling strategies.
//!
//! Key features:
//! - Zero-lock design: Each thread operates independently
//! - Intelligent sampling: Frequency + size dual-dimension sampling
//! - Binary format: Uses bincode for zero-overhead serialization
//! - Thread isolation: Complete elimination of shared state
//! - Performance focused: Minimal overhead on target application

use bincode::{Decode, Encode};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{SystemTime, UNIX_EPOCH};

// EventType moved to analysis.rs to avoid duplication
pub use crate::lockfree::analysis::EventType;

/// Enhanced tracking event with rich metadata
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub struct Event {
    pub timestamp: u64,
    pub ptr: usize,
    pub size: usize,
    pub call_stack_hash: u64,
    pub event_type: EventType,
    pub thread_id: u64,
    /// Full call stack addresses (limited to prevent explosion)
    pub call_stack: Vec<usize>,
    /// CPU time consumed by this thread (nanoseconds)
    pub cpu_time_ns: u64,
    /// Memory alignment used for this allocation
    pub alignment: usize,
    /// Allocation category (Small/Medium/Large)
    pub allocation_category: AllocationCategory,
    /// Thread name if available
    pub thread_name: Option<String>,
    /// Process memory stats at time of allocation
    pub memory_stats: MemoryStats,
    /// Real call stack with symbols (when available)
    #[cfg(feature = "backtrace")]
    pub real_call_stack: Option<RealCallStack>,
    /// System performance metrics
    #[cfg(feature = "system-metrics")]
    pub system_metrics: Option<SystemMetrics>,
    /// Advanced analysis data
    #[cfg(feature = "advanced-analysis")]
    pub analysis_data: Option<AnalysisData>,
}

/// Enhanced frequency tracking data
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub struct FrequencyData {
    pub call_stack_hash: u64,
    pub frequency: u64,
    pub total_size: usize,
    pub thread_id: u64,
    /// Average allocation size for this call stack
    pub avg_size: f64,
    /// Min and max sizes observed
    pub size_range: (usize, usize),
    /// First and last seen timestamps
    pub time_range: (u64, u64),
    /// CPU time spent in allocations from this call stack
    pub total_cpu_time: u64,
}

/// Memory allocation category
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub enum AllocationCategory {
    Small,  // < 2KB
    Medium, // 2KB - 64KB
    Large,  // >= 64KB
}

/// Process memory statistics snapshot
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub struct MemoryStats {
    /// Virtual memory size in bytes
    pub virtual_memory: usize,
    /// Resident memory size in bytes
    pub resident_memory: usize,
    /// Heap memory in use
    pub heap_memory: usize,
    /// Number of page faults
    pub page_faults: u64,
}

/// Real call stack with symbol information
#[cfg(feature = "backtrace")]
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub struct RealCallStack {
    /// Raw addresses from backtrace
    pub addresses: Vec<usize>,
    /// Resolved symbols with function names
    pub symbols: Vec<StackFrame>,
    /// Call stack depth
    pub depth: usize,
}

#[cfg(feature = "backtrace")]
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub struct StackFrame {
    /// Function name if available
    pub function_name: Option<String>,
    /// File name if available
    pub filename: Option<String>,
    /// Line number if available
    pub line_number: Option<u32>,
    /// Memory address
    pub address: usize,
}

/// System performance metrics
#[cfg(feature = "system-metrics")]
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub struct SystemMetrics {
    /// CPU usage percentage (0-100)
    pub cpu_usage: f32,
    /// Available memory in bytes
    pub available_memory: u64,
    /// Total memory in bytes
    pub total_memory: u64,
    /// Load average (1, 5, 15 minutes)
    pub load_average: (f64, f64, f64),
    /// Number of active threads in process
    pub thread_count: usize,
    /// Current memory fragmentation ratio
    pub fragmentation_ratio: f32,
}

/// Advanced analysis data
#[cfg(feature = "advanced-analysis")]
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub struct AnalysisData {
    /// Allocation lifetime prediction
    pub predicted_lifetime_ms: u64,
    /// Allocation frequency pattern
    pub frequency_pattern: FrequencyPattern,
    /// Cross-thread sharing likelihood
    pub sharing_likelihood: f32,
    /// Memory access pattern prediction
    pub access_pattern: AccessPattern,
    /// Performance impact score (0-100)
    pub performance_impact: u8,
}

#[cfg(feature = "advanced-analysis")]
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub enum FrequencyPattern {
    Sporadic,
    Regular,
    Burst,
    Constant,
}

#[cfg(feature = "advanced-analysis")]
#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
pub enum AccessPattern {
    Sequential,
    Random,
    Hotspot,
    Cached,
}

// Use sampling config from sampling module
pub use crate::lockfree::sampling::SamplingConfig;

// SamplingConfig is now defined in sampling.rs

// Thread-local tracker that operates completely independently
// Uses RefCell for interior mutability without locks
thread_local! {
    static THREAD_TRACKER: std::cell::RefCell<Option<ThreadLocalTracker>> =
        const { std::cell::RefCell::new(None) };
}

/// Thread-local memory tracker with enhanced metadata collection
#[derive(Debug)]
pub struct ThreadLocalTracker {
    /// Thread ID for identification
    thread_id: u64,
    /// Event buffer for batch writing
    event_buffer: Vec<Event>,
    /// Call stack frequency tracking
    call_stack_frequencies: HashMap<u64, u64>,
    /// Call stack size tracking for intelligent sampling
    call_stack_sizes: HashMap<u64, usize>,
    /// Call stack size ranges for statistics
    call_stack_size_ranges: HashMap<u64, (usize, usize)>,
    /// Call stack time ranges for temporal analysis
    call_stack_time_ranges: HashMap<u64, (u64, u64)>,
    /// Call stack CPU time accumulation
    call_stack_cpu_times: HashMap<u64, u64>,
    /// Buffer size before flushing to disk
    buffer_size: usize,
    /// File handle for writing events
    file_path: std::path::PathBuf,
    /// Sampling configuration
    config: SamplingConfig,
    /// Random number generator for sampling decisions
    rng_state: u64,
    /// Thread name if detected
    thread_name: Option<String>,
    /// Start time for CPU time calculations
    start_time: std::time::Instant,
    /// Thread history for advanced analysis
    #[cfg(feature = "advanced-analysis")]
    thread_history: HashMap<u64, (u64, u64)>, // call_stack_hash -> (last_time, count)
    /// Performance sampling counter to limit overhead
    performance_sample_counter: u64,
}

impl ThreadLocalTracker {
    /// Creates a new thread-local tracker with specified configuration
    ///
    /// # Arguments
    /// * `output_dir` - Directory for storing thread-specific binary files
    /// * `config` - Sampling configuration for intelligent allocation tracking
    ///
    /// # Returns
    /// Result containing the configured tracker or IO error
    pub fn new(output_dir: &std::path::Path, config: SamplingConfig) -> std::io::Result<Self> {
        let thread_id = get_thread_id();
        let file_path = output_dir.join(format!("memscope_thread_{}.bin", thread_id));

        // Ensure output directory exists before creating tracker
        if let Some(parent) = file_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        // Pre-allocate buffer for optimal performance
        let event_buffer = Vec::with_capacity(1000);

        // Try to get thread name
        let thread_name = std::thread::current().name().map(|s| s.to_string());

        Ok(Self {
            thread_id,
            event_buffer,
            call_stack_frequencies: HashMap::new(),
            call_stack_sizes: HashMap::new(),
            call_stack_size_ranges: HashMap::new(),
            call_stack_time_ranges: HashMap::new(),
            call_stack_cpu_times: HashMap::new(),
            buffer_size: 1000,
            file_path,
            config,
            rng_state: thread_id, // Thread ID as deterministic seed
            thread_name,
            start_time: std::time::Instant::now(),
            #[cfg(feature = "advanced-analysis")]
            thread_history: HashMap::new(),
            performance_sample_counter: 0,
        })
    }

    /// Tracks allocation with enhanced metadata collection
    ///
    /// # Arguments
    /// * `ptr` - Memory pointer address
    /// * `size` - Allocation size in bytes
    /// * `call_stack` - Full call stack for detailed tracking
    ///
    /// # Returns
    /// Result indicating success or error during tracking/flushing
    pub fn track_allocation(
        &mut self,
        ptr: usize,
        size: usize,
        call_stack: &[usize],
    ) -> Result<(), Box<dyn std::error::Error>> {
        let call_stack_hash = calculate_call_stack_hash(call_stack);
        // Update frequency tracking for intelligent sampling
        let frequency = self
            .call_stack_frequencies
            .entry(call_stack_hash)
            .or_insert(0);
        *frequency += 1;
        let current_frequency = *frequency;
        self.call_stack_sizes.insert(call_stack_hash, size);

        // Update size ranges for this call stack
        let size_range = self
            .call_stack_size_ranges
            .entry(call_stack_hash)
            .or_insert((size, size));
        size_range.0 = size_range.0.min(size);
        size_range.1 = size_range.1.max(size);

        // Update time ranges
        let timestamp = get_timestamp();
        let time_range = self
            .call_stack_time_ranges
            .entry(call_stack_hash)
            .or_insert((timestamp, timestamp));
        time_range.0 = time_range.0.min(timestamp);
        time_range.1 = time_range.1.max(timestamp);

        // Calculate CPU time elapsed
        let cpu_time_ns = self.start_time.elapsed().as_nanos() as u64;
        *self
            .call_stack_cpu_times
            .entry(call_stack_hash)
            .or_insert(0) += cpu_time_ns / 1000; // Rough estimate

        // For demo purposes, force sampling of more allocations
        if self.should_sample_allocation(size, current_frequency) || current_frequency <= 10 {
            // Update performance sampling counter
            self.performance_sample_counter += 1;
            let _should_collect_enhanced = self.performance_sample_counter % 10 == 0; // Sample every 10th allocation

            // Update thread history for advanced analysis
            #[cfg(feature = "advanced-analysis")]
            {
                self.thread_history
                    .insert(call_stack_hash, (timestamp, current_frequency));
            }

            let event = Event {
                timestamp,
                ptr,
                size,
                call_stack_hash,
                event_type: EventType::Allocation,
                thread_id: self.thread_id,
                call_stack: call_stack.to_vec(),
                cpu_time_ns,
                alignment: get_alignment_for_size(size),
                allocation_category: categorize_allocation(size),
                thread_name: self.thread_name.clone(),
                memory_stats: get_memory_stats(),

                // Enhanced data collection (performance-gated)
                #[cfg(feature = "backtrace")]
                real_call_stack: if _should_collect_enhanced {
                    capture_real_call_stack()
                } else {
                    None
                },

                #[cfg(feature = "system-metrics")]
                system_metrics: if _should_collect_enhanced {
                    collect_system_metrics()
                } else {
                    None
                },

                #[cfg(feature = "advanced-analysis")]
                analysis_data: if _should_collect_enhanced {
                    analyze_allocation_pattern(
                        size,
                        current_frequency,
                        call_stack_hash,
                        &self.thread_history,
                    )
                } else {
                    None
                },
            };

            self.event_buffer.push(event);

            // Flush buffer when full to prevent memory bloat
            if self.event_buffer.len() >= self.buffer_size {
                self.flush_buffer()?;
            }
        }

        Ok(())
    }

    /// Tracks deallocation events for memory balance analysis
    ///
    /// # Arguments
    /// * `ptr` - Memory pointer address being deallocated
    /// * `call_stack` - Full call stack for correlation
    ///
    /// # Returns
    /// Result indicating success or error during tracking/flushing
    pub fn track_deallocation(
        &mut self,
        ptr: usize,
        call_stack: &[usize],
    ) -> Result<(), Box<dyn std::error::Error>> {
        let call_stack_hash = calculate_call_stack_hash(call_stack);
        // Use consistent sampling logic for deallocations with forced early sampling
        let frequency = self
            .call_stack_frequencies
            .get(&call_stack_hash)
            .copied()
            .unwrap_or(1);
        let size = self
            .call_stack_sizes
            .get(&call_stack_hash)
            .copied()
            .unwrap_or(0);

        if self.should_sample_allocation(size, frequency) || frequency <= 10 {
            let timestamp = get_timestamp();
            let cpu_time_ns = self.start_time.elapsed().as_nanos() as u64;

            // Performance-gated enhanced collection for deallocations too
            self.performance_sample_counter += 1;
            let _should_collect_enhanced = self.performance_sample_counter % 20 == 0; // Less frequent for deallocations

            let event = Event {
                timestamp,
                ptr,
                size: 0, // Size not required for deallocation events
                call_stack_hash,
                event_type: EventType::Deallocation,
                thread_id: self.thread_id,
                call_stack: call_stack.to_vec(),
                cpu_time_ns,
                alignment: 0, // Not applicable for deallocations
                allocation_category: AllocationCategory::Small, // Default for deallocations
                thread_name: self.thread_name.clone(),
                memory_stats: get_memory_stats(),

                // Enhanced data collection (performance-gated)
                #[cfg(feature = "backtrace")]
                real_call_stack: if _should_collect_enhanced {
                    capture_real_call_stack()
                } else {
                    None
                },

                #[cfg(feature = "system-metrics")]
                system_metrics: if _should_collect_enhanced {
                    collect_system_metrics()
                } else {
                    None
                },

                #[cfg(feature = "advanced-analysis")]
                analysis_data: if _should_collect_enhanced {
                    self.thread_history
                        .get(&call_stack_hash)
                        .and_then(|(_, freq)| {
                            analyze_allocation_pattern(
                                size,
                                *freq,
                                call_stack_hash,
                                &self.thread_history,
                            )
                        })
                } else {
                    None
                },
            };

            self.event_buffer.push(event);

            // Flush buffer when full to prevent memory bloat
            if self.event_buffer.len() >= self.buffer_size {
                self.flush_buffer()?;
            }
        }

        Ok(())
    }

    /// Determines sampling decision using dual-dimension analysis
    ///
    /// Combines size-based and frequency-based sampling for intelligent allocation tracking.
    /// Large allocations and high-frequency patterns receive higher sampling rates.
    ///
    /// # Arguments
    /// * `size` - Allocation size in bytes
    /// * `frequency` - Current frequency count for this call stack
    ///
    /// # Returns
    /// Boolean indicating whether to sample this allocation
    fn should_sample_allocation(&mut self, size: usize, frequency: u64) -> bool {
        // Determine base sampling rate by allocation size
        let size_based_rate = match size {
            s if s >= self.config.large_threshold => self.config.large_allocation_rate,
            s if s >= self.config.medium_threshold => self.config.medium_allocation_rate,
            _ => self.config.small_allocation_rate,
        };

        // Apply frequency-based boost for performance-critical patterns
        let frequency_multiplier = if frequency > self.config.frequency_threshold {
            // High frequency allocations indicate performance hotspots
            (frequency as f64 / self.config.frequency_threshold as f64).min(10.0)
        } else {
            1.0
        };

        let final_rate = (size_based_rate * frequency_multiplier).min(1.0);

        // For demo config with 100% sampling rates, always sample
        if size_based_rate >= 1.0 {
            return true;
        }

        // Fast linear congruential generator for sampling decision
        self.rng_state = self.rng_state.wrapping_mul(1103515245).wrapping_add(12345);
        let random_value = (self.rng_state >> 16) as f64 / 65536.0;

        // For demo purposes, be much more generous with sampling
        let adjusted_rate = if final_rate > 0.8 {
            1.0
        } else {
            (final_rate * 2.0).min(1.0) // Double the sampling rate
        };

        random_value < adjusted_rate
    }

    /// Flush event buffer to binary file
    fn flush_buffer(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        if self.event_buffer.is_empty() {
            return Ok(());
        }

        // Serialize events using bincode (zero-overhead binary format)
        let serialized = bincode::encode_to_vec(&self.event_buffer, bincode::config::standard())?;

        // Append to file (create if doesn't exist)
        use std::fs::OpenOptions;
        use std::io::Write;

        let mut file = OpenOptions::new()
            .create(true)
            .append(true)
            .open(&self.file_path)?;

        // Write length header (4 bytes) followed by data
        let len = serialized.len() as u32;
        file.write_all(&len.to_le_bytes())?;
        file.write_all(&serialized)?;
        file.flush()?;

        // Clear buffer
        self.event_buffer.clear();

        Ok(())
    }

    /// Export enhanced frequency data at the end of tracking
    pub fn export_frequency_data(&self) -> Result<(), Box<dyn std::error::Error>> {
        let frequency_data: Vec<FrequencyData> = self
            .call_stack_frequencies
            .iter()
            .map(|(&call_stack_hash, &frequency)| {
                let size = self
                    .call_stack_sizes
                    .get(&call_stack_hash)
                    .copied()
                    .unwrap_or(0);
                let total_size = size * frequency as usize;
                let size_range = self
                    .call_stack_size_ranges
                    .get(&call_stack_hash)
                    .copied()
                    .unwrap_or((size, size));
                let time_range = self
                    .call_stack_time_ranges
                    .get(&call_stack_hash)
                    .copied()
                    .unwrap_or((0, 0));
                let total_cpu_time = self
                    .call_stack_cpu_times
                    .get(&call_stack_hash)
                    .copied()
                    .unwrap_or(0);

                FrequencyData {
                    call_stack_hash,
                    frequency,
                    total_size,
                    thread_id: self.thread_id,
                    avg_size: if frequency > 0 {
                        total_size as f64 / frequency as f64
                    } else {
                        0.0
                    },
                    size_range,
                    time_range,
                    total_cpu_time,
                }
            })
            .collect();

        let frequency_file = self.file_path.with_extension("freq");
        let serialized = bincode::encode_to_vec(&frequency_data, bincode::config::standard())?;

        std::fs::write(frequency_file, serialized)?;
        Ok(())
    }

    /// Force flush any remaining events
    pub fn finalize(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        self.flush_buffer()?;
        self.export_frequency_data()?;
        Ok(())
    }
}

impl Drop for ThreadLocalTracker {
    fn drop(&mut self) {
        // Ensure all data is flushed on drop
        let _ = self.finalize();
    }
}

/// Get unique thread ID
fn get_thread_id() -> u64 {
    static THREAD_COUNTER: AtomicU64 = AtomicU64::new(1);

    thread_local! {
        static THREAD_ID: u64 = THREAD_COUNTER.fetch_add(1, Ordering::Relaxed);
    }

    THREAD_ID.with(|&id| id)
}

/// Gets current timestamp in nanoseconds with fallback to zero
///
/// Uses system time but handles clock errors gracefully without panicking
fn get_timestamp() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|duration| duration.as_nanos() as u64)
        .unwrap_or(0)
}

/// Determine appropriate alignment for allocation size
fn get_alignment_for_size(size: usize) -> usize {
    match size {
        0..=8 => 8,
        9..=16 => 16,
        17..=32 => 32,
        33..=64 => 64,
        _ => 64, // Default alignment for larger allocations
    }
}

/// Categorize allocation by size
fn categorize_allocation(size: usize) -> AllocationCategory {
    match size {
        0..=2048 => AllocationCategory::Small,
        2049..=65536 => AllocationCategory::Medium,
        _ => AllocationCategory::Large,
    }
}

/// Capture real call stack with symbols
#[cfg(feature = "backtrace")]
fn capture_real_call_stack() -> Option<RealCallStack> {
    let mut addresses = Vec::new();
    let mut symbols = Vec::new();

    // Capture backtrace with limited depth for performance
    backtrace::trace(|frame| {
        let addr = frame.ip() as usize;
        addresses.push(addr);

        // Resolve symbols for this frame
        backtrace::resolve_frame(frame, |symbol| {
            let function_name = symbol.name().map(|n| format!("{}", n));
            let filename = symbol.filename().and_then(|f| f.to_str().map(String::from));
            let line_number = symbol.lineno();

            symbols.push(StackFrame {
                function_name,
                filename,
                line_number,
                address: addr,
            });
        });

        // Limit call stack depth for performance
        addresses.len() < 16
    });

    if addresses.is_empty() {
        None
    } else {
        let depth = symbols.len();
        Some(RealCallStack {
            addresses,
            symbols,
            depth,
        })
    }
}

/// Collect system performance metrics
#[cfg(feature = "system-metrics")]
fn collect_system_metrics() -> Option<SystemMetrics> {
    use sysinfo::{Pid, System};

    // Use thread-local system info to avoid repeated initialization
    thread_local! {
        static SYSTEM: std::cell::RefCell<System> = std::cell::RefCell::new(System::new_all());
    }

    SYSTEM.with(|sys| {
        let mut system = sys.borrow_mut();
        system.refresh_cpu_all();
        system.refresh_memory();
        system.refresh_processes(sysinfo::ProcessesToUpdate::All, true);

        // Get CPU usage (sysinfo 0.30+ API)
        let cpu_usage = system.global_cpu_usage();
        let available_memory = system.available_memory();
        let total_memory = system.total_memory();

        // Get load average using new API
        let load_avg = System::load_average();

        // Count processes instead of threads (more reliable)
        let current_pid = sysinfo::get_current_pid().ok()?;
        let thread_count = if system
            .process(Pid::from_u32(current_pid.as_u32()))
            .is_some()
        {
            // Estimate thread count as we can't access tasks directly
            num_cpus::get()
        } else {
            1
        };

        // Calculate fragmentation ratio estimate
        let used_memory = total_memory - available_memory;
        let fragmentation_ratio = if total_memory > 0 {
            (used_memory as f32 / total_memory as f32).min(1.0)
        } else {
            0.0
        };

        Some(SystemMetrics {
            cpu_usage,
            available_memory,
            total_memory,
            load_average: (load_avg.one, load_avg.five, load_avg.fifteen),
            thread_count,
            fragmentation_ratio,
        })
    })
}

/// Perform advanced analysis on allocation pattern
#[cfg(feature = "advanced-analysis")]
fn analyze_allocation_pattern(
    size: usize,
    frequency: u64,
    _call_stack_hash: u64,
    _thread_history: &HashMap<u64, (u64, u64)>, // (last_time, count)
) -> Option<AnalysisData> {
    // Predict allocation lifetime based on size and frequency
    let predicted_lifetime_ms = match size {
        0..=1024 => 10 + (frequency * 2), // Small allocations are short-lived
        1025..=32768 => 100 + (frequency * 5), // Medium allocations
        _ => 1000 + (frequency * 10),     // Large allocations live longer
    };

    // Determine frequency pattern
    let frequency_pattern = match frequency {
        1..=5 => FrequencyPattern::Sporadic,
        6..=20 => FrequencyPattern::Regular,
        21..=100 => FrequencyPattern::Burst,
        _ => FrequencyPattern::Constant,
    };

    // Estimate sharing likelihood based on call stack commonality
    let sharing_likelihood = if frequency > 50 {
        0.8 // High frequency suggests shared usage
    } else if frequency > 10 {
        0.4
    } else {
        0.1
    };

    // Predict access pattern based on size and frequency
    let access_pattern = match (size, frequency) {
        (0..=64, f) if f > 100 => AccessPattern::Hotspot,
        (65..=4096, _) => AccessPattern::Sequential,
        (_, f) if f > 20 => AccessPattern::Cached,
        _ => AccessPattern::Random,
    };

    // Calculate performance impact score
    let performance_impact =
        ((frequency.min(100) as f64 * size.min(100000) as f64) / 10000.0) as u8;

    Some(AnalysisData {
        predicted_lifetime_ms,
        frequency_pattern,
        sharing_likelihood,
        access_pattern,
        performance_impact,
    })
}

/// Get current process memory statistics
fn get_memory_stats() -> MemoryStats {
    #[cfg(target_os = "linux")]
    {
        // Try to read from /proc/self/status on Linux
        if let Ok(status) = std::fs::read_to_string("/proc/self/status") {
            let mut vm_size = 0;
            let mut vm_rss = 0;

            for line in status.lines() {
                if line.starts_with("VmSize:") {
                    if let Some(kb_str) = line.split_whitespace().nth(1) {
                        vm_size = kb_str.parse::<usize>().unwrap_or(0) * 1024;
                    }
                } else if line.starts_with("VmRSS:") {
                    if let Some(kb_str) = line.split_whitespace().nth(1) {
                        vm_rss = kb_str.parse::<usize>().unwrap_or(0) * 1024;
                    }
                }
            }

            MemoryStats {
                virtual_memory: vm_size,
                resident_memory: vm_rss,
                heap_memory: vm_rss / 2, // Rough estimate
                page_faults: 0,          // Would need separate syscall
            }
        } else {
            MemoryStats {
                virtual_memory: 0,
                resident_memory: 0,
                heap_memory: 0,
                page_faults: 0,
            }
        }
    }

    #[cfg(target_os = "macos")]
    {
        // Basic memory estimation for macOS
        MemoryStats {
            virtual_memory: 100 * 1024 * 1024, // 100MB estimate
            resident_memory: 50 * 1024 * 1024, // 50MB estimate
            heap_memory: 25 * 1024 * 1024,     // 25MB estimate
            page_faults: 0,
        }
    }

    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        // Default fallback for other platforms
        MemoryStats {
            virtual_memory: 0,
            resident_memory: 0,
            heap_memory: 0,
            page_faults: 0,
        }
    }
}

/// Calculate hash for call stack (simplified for now)
pub fn calculate_call_stack_hash(call_stack: &[usize]) -> u64 {
    let mut hasher = DefaultHasher::new();
    call_stack.hash(&mut hasher);
    hasher.finish()
}

/// Global API functions for thread-local tracking
/// Initialize thread-local tracker for current thread
pub fn init_thread_tracker(
    output_dir: &std::path::Path,
    config: Option<SamplingConfig>,
) -> Result<(), Box<dyn std::error::Error>> {
    let config = config.unwrap_or_default();

    THREAD_TRACKER.with(|tracker| {
        let mut tracker_ref = tracker.borrow_mut();
        if tracker_ref.is_none() {
            *tracker_ref = Some(ThreadLocalTracker::new(output_dir, config)?);
        }
        Ok(())
    })
}

/// Track allocation in current thread using lock-free approach
pub fn track_allocation_lockfree(
    ptr: usize,
    size: usize,
    call_stack: &[usize],
) -> Result<(), Box<dyn std::error::Error>> {
    THREAD_TRACKER.with(|tracker| {
        let mut tracker_ref = tracker.borrow_mut();
        if let Some(ref mut t) = *tracker_ref {
            t.track_allocation(ptr, size, call_stack)
        } else {
            Err("Thread tracker not initialized. Call init_thread_tracker() first.".into())
        }
    })
}

/// Track deallocation in current thread using lock-free approach
pub fn track_deallocation_lockfree(
    ptr: usize,
    call_stack: &[usize],
) -> Result<(), Box<dyn std::error::Error>> {
    THREAD_TRACKER.with(|tracker| {
        let mut tracker_ref = tracker.borrow_mut();
        if let Some(ref mut t) = *tracker_ref {
            t.track_deallocation(ptr, call_stack)
        } else {
            Err("Thread tracker not initialized. Call init_thread_tracker() first.".into())
        }
    })
}

/// Finalize tracking for current thread
pub fn finalize_thread_tracker() -> Result<(), Box<dyn std::error::Error>> {
    THREAD_TRACKER.with(|tracker| {
        let mut tracker_ref = tracker.borrow_mut();
        if let Some(ref mut t) = *tracker_ref {
            t.finalize()
        } else {
            Ok(()) // No tracker initialized, nothing to finalize
        }
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::Arc;
    use std::thread;

    #[test]
    fn test_thread_local_tracking_basic() {
        let temp_dir = std::env::temp_dir().join("memscope_test");
        std::fs::create_dir_all(&temp_dir).unwrap();

        // Get thread ID before initializing tracker
        let thread_id = get_thread_id();

        let config = SamplingConfig::demo(); // Use demo config for 100% sampling
        init_thread_tracker(&temp_dir, Some(config)).unwrap();

        let call_stack = vec![0x1000, 0x2000, 0x3000];
        track_allocation_lockfree(0x4000, 1024, &call_stack)
            .expect("Allocation tracking should succeed");
        track_deallocation_lockfree(0x4000, &call_stack)
            .expect("Deallocation tracking should succeed");

        finalize_thread_tracker().unwrap();

        // Check that files were created using the thread ID we got earlier
        let event_file = temp_dir.join(format!("memscope_thread_{}.bin", thread_id));
        let freq_file = temp_dir.join(format!("memscope_thread_{}.freq", thread_id));

        // Debug: list files in directory if assertion fails
        if !event_file.exists() || !freq_file.exists() {
            println!("Files in temp directory:");
            if let Ok(entries) = std::fs::read_dir(&temp_dir) {
                for entry in entries.flatten() {
                    println!("  - {:?}", entry.file_name());
                }
            }
        }

        assert!(
            event_file.exists(),
            "Event file should exist: {:?}",
            event_file
        );
        assert!(
            freq_file.exists(),
            "Frequency file should exist: {:?}",
            freq_file
        );

        // Cleanup
        let _ = std::fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn test_multi_thread_independence() {
        let temp_dir = std::env::temp_dir().join("memscope_multithread_test");
        std::fs::create_dir_all(&temp_dir).unwrap();

        let thread_count = 10;
        let allocations_per_thread = 100;
        let counter = Arc::new(AtomicUsize::new(0));
        let thread_ids = Arc::new(std::sync::Mutex::new(Vec::new()));

        let handles: Vec<_> = (0..thread_count)
            .map(|thread_idx| {
                let temp_dir = temp_dir.clone();
                let counter = Arc::clone(&counter);
                let thread_ids = Arc::clone(&thread_ids);

                thread::spawn(move || {
                    // Initialize tracker for this thread
                    init_thread_tracker(&temp_dir, None).unwrap();

                    // Get and store the actual thread ID
                    let actual_thread_id = get_thread_id();
                    thread_ids.lock().unwrap().push(actual_thread_id);

                    for i in 0..allocations_per_thread {
                        let ptr = thread_idx * 10000 + i * 8;
                        let size = 64 + (i % 10) * 64; // Varying sizes
                        let call_stack = vec![0x1000 + thread_idx, 0x2000 + i];

                        track_allocation_lockfree(ptr, size, &call_stack)
                            .expect("Allocation tracking should succeed");

                        // Simulate some deallocations
                        if i % 3 == 0 {
                            track_deallocation_lockfree(ptr, &call_stack)
                                .expect("Deallocation tracking should succeed");
                        }

                        counter.fetch_add(1, Ordering::Relaxed);
                    }

                    finalize_thread_tracker().unwrap();
                })
            })
            .collect();

        // Wait for all threads to complete
        for handle in handles {
            handle.join().unwrap();
        }

        // Verify all operations completed
        assert_eq!(
            counter.load(Ordering::Relaxed),
            thread_count * allocations_per_thread
        );

        // Verify each thread created its own files using actual thread IDs
        let actual_thread_ids = thread_ids.lock().unwrap();
        for &thread_id in actual_thread_ids.iter() {
            let event_file = temp_dir.join(format!("memscope_thread_{}.bin", thread_id));
            let freq_file = temp_dir.join(format!("memscope_thread_{}.freq", thread_id));

            // Debug: list files in directory if assertion fails
            if !event_file.exists() || !freq_file.exists() {
                println!("Files in temp directory for thread {}:", thread_id);
                if let Ok(entries) = std::fs::read_dir(&temp_dir) {
                    for entry in entries.flatten() {
                        println!("  - {:?}", entry.file_name());
                    }
                }
            }

            assert!(
                event_file.exists(),
                "Event file missing for thread {}",
                thread_id
            );
            assert!(
                freq_file.exists(),
                "Frequency file missing for thread {}",
                thread_id
            );
        }

        // Cleanup
        let _ = std::fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn test_intelligent_sampling() {
        let config = SamplingConfig {
            small_allocation_rate: 0.1,  // 10% for small
            medium_allocation_rate: 0.5, // 50% for medium
            large_allocation_rate: 1.0,  // 100% for large
            ..Default::default()
        };

        let temp_dir = std::env::temp_dir().join("memscope_sampling_test");
        std::fs::create_dir_all(&temp_dir).unwrap();

        let mut tracker = ThreadLocalTracker::new(&temp_dir, config).unwrap();

        let mut sampled_small = 0;
        let mut sampled_large = 0;
        let total_small = 100;
        let total_large = 10;

        // Test small allocations (should have lower sample rate)
        for _i in 0..total_small {
            let size = 512; // Small allocation
            let was_sampled = tracker.should_sample_allocation(size, 1);
            if was_sampled {
                sampled_small += 1;
            }
        }

        // Test large allocations (should have higher sample rate)
        for _i in 0..total_large {
            let size = 20 * 1024; // Large allocation
            let was_sampled = tracker.should_sample_allocation(size, 1);
            if was_sampled {
                sampled_large += 1;
            }
        }

        // Large allocations should be sampled more frequently
        assert!(
            sampled_large as f64 / total_large as f64 > sampled_small as f64 / total_small as f64
        );

        // Cleanup
        let _ = std::fs::remove_dir_all(&temp_dir);
    }
}