testlint_sdk/profiler/

cpp.rs

#![allow(dead_code)]

use crate::profiler::ProfileResult;
use std::fs;
use std::path::Path;
use std::process::{Command, Stdio};

pub struct CppProfiler;

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

impl CppProfiler {
    pub fn new() -> Self {
        CppProfiler
    }

    /// Continuous profiling of C++ applications using platform-specific profilers
    /// Runs until the process exits or is interrupted
    pub fn profile_continuous(&self, cpp_binary: &str) -> Result<ProfileResult, String> {
        println!("⚙️  Starting C++ runtime profiling...");
        println!("📝 Note: Binary should be compiled with -g for debugging symbols");

        // Try platform-specific profilers first
        #[cfg(target_os = "macos")]
        {
            println!("📝 macOS detected - using sample/Instruments for profiling");
            self.profile_macos(cpp_binary)
        }

        #[cfg(target_os = "windows")]
        {
            println!("📝 Windows detected - using Windows Performance Recorder");
            self.profile_windows(cpp_binary)
        }

        // Linux: Try perf first, then fall back to valgrind
        #[cfg(target_os = "linux")]
        {
            println!("📝 Linux detected - using perf for profiling");
            if self.is_perf_available() {
                return self.profile_with_perf(cpp_binary);
            }

            // Try valgrind/callgrind (cross-platform fallback)
            if self.is_valgrind_available() {
                return self.profile_with_valgrind(cpp_binary);
            }

            Err("No profiling tool found. Please install:\n\
                 - Linux: perf (apt-get install linux-tools-generic)\n\
                 - Any OS: valgrind (apt-get install valgrind / brew install valgrind)"
                .to_string())
        }

        #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
        {
            Err("C++ profiling is not supported on this platform".to_string())
        }
    }

    /// Profile on macOS using sample command
    #[cfg(target_os = "macos")]
    fn profile_macos(&self, binary: &str) -> Result<ProfileResult, String> {
        println!("🍎 Profiling on macOS using 'sample' command...");

        let output_file = "cpp_profile.txt";

        // Check if binary exists
        if !Path::new(binary).exists() {
            return Err(format!("Binary not found: {}", binary));
        }

        println!("Running: sample {} 10 -file {}", binary, output_file);
        println!("Profiling for 10 seconds...");

        let mut cmd = Command::new("sample");
        cmd.arg(binary);
        cmd.arg("10"); // Sample for 10 seconds
        cmd.arg("-file");
        cmd.arg(output_file);

        let output = cmd
            .output()
            .map_err(|e| format!("Failed to run sample command: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "sample failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        Ok(ProfileResult {
            language: "C++".to_string(),
            details: vec![
                "✓ Profiling completed successfully".to_string(),
                format!("📊 Profile data saved to {}", output_file),
                "".to_string(),
                "macOS 'sample' command output includes:".to_string(),
                "  - Call tree showing function hierarchy".to_string(),
                "  - Sample counts per function".to_string(),
                "  - Binary image information".to_string(),
                "".to_string(),
                format!("To view the profile: open {}", output_file),
                "".to_string(),
                "For GUI profiling, use Instruments:".to_string(),
                format!("  instruments -t 'Time Profiler' {}", binary),
            ],
        })
    }

    #[cfg(not(target_os = "macos"))]
    #[allow(dead_code)]
    fn profile_macos(&self, _binary: &str) -> Result<ProfileResult, String> {
        Err("macOS profiling is only available on macOS".to_string())
    }

    /// Profile on Windows using Windows Performance Recorder
    #[cfg(target_os = "windows")]
    fn profile_windows(&self, binary: &str) -> Result<ProfileResult, String> {
        println!("🪟 Profiling on Windows using Windows Performance Recorder...");

        let output_file = "cpp_profile.etl";

        // Check if binary exists
        let binary_path = if !binary.ends_with(".exe") {
            format!("{}.exe", binary)
        } else {
            binary.to_string()
        };

        if !Path::new(&binary_path).exists() {
            return Err(format!("Binary not found: {}", binary_path));
        }

        println!("Starting Windows Performance Recorder...");
        println!("Run your application, then press Ctrl+C to stop recording.");

        // Start recording
        let mut cmd = Command::new("wpr");
        cmd.args(["-start", "CPU"]);

        let output = cmd
            .output()
            .map_err(|e| format!("Failed to start WPR: {}. Is WPR installed?", e))?;

        if !output.status.success() {
            return Err(format!(
                "WPR failed to start: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        println!("Recording started. Running {}...", binary_path);

        // Run the application
        let app_output = Command::new(&binary_path)
            .output()
            .map_err(|e| format!("Failed to run application: {}", e))?;

        if !app_output.status.success() {
            println!(
                "⚠️  Application exited with error: {}",
                String::from_utf8_lossy(&app_output.stderr)
            );
        }

        // Stop recording
        println!("Stopping Windows Performance Recorder...");
        let mut stop_cmd = Command::new("wpr");
        stop_cmd.args(["-stop", output_file]);

        let stop_output = stop_cmd
            .output()
            .map_err(|e| format!("Failed to stop WPR: {}", e))?;

        if !stop_output.status.success() {
            return Err(format!(
                "WPR failed to stop: {}",
                String::from_utf8_lossy(&stop_output.stderr)
            ));
        }

        Ok(ProfileResult {
            language: "C++".to_string(),
            details: vec![
                "✓ Profiling completed successfully".to_string(),
                format!("📊 Profile data saved to {}", output_file),
                "".to_string(),
                "To analyze the profile with Windows Performance Analyzer (WPA):".to_string(),
                format!("  wpa {}", output_file),
                "".to_string(),
                "WPA provides:".to_string(),
                "  - Detailed CPU usage analysis".to_string(),
                "  - Call stacks and flame graphs".to_string(),
                "  - Function-level performance metrics".to_string(),
                "".to_string(),
                "Note: WPA is part of the Windows Performance Toolkit".to_string(),
                "  Download from: https://docs.microsoft.com/en-us/windows-hardware/get-started/adk-install".to_string(),
            ],
        })
    }

    #[cfg(not(target_os = "windows"))]
    #[allow(dead_code)]
    fn profile_windows(&self, _binary: &str) -> Result<ProfileResult, String> {
        Err("Windows profiling is only available on Windows".to_string())
    }

    /// Profile using perf (Linux)
    #[cfg(target_os = "linux")]
    fn profile_with_perf(&self, binary: &str) -> Result<ProfileResult, String> {
        println!("🔍 Profiling with perf...");

        let perf_data = "perf.data";

        let mut cmd = Command::new("perf");
        cmd.args(["record", "-F", "99", "-g", "--", binary]);

        println!("Running: perf record -F 99 -g -- {}", binary);
        println!("Profiling until program exits...");

        let output = cmd
            .output()
            .map_err(|e| format!("Failed to run perf: {}", e))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);

            if stderr.contains("permission") || stderr.contains("Operation not permitted") {
                return Err("Permission denied. perf may require elevated privileges.\n\
                     Try: sudo sysctl kernel.perf_event_paranoid=0\n\
                     Or run with: sudo -E env PATH=$PATH <your command>"
                    .to_string());
            }

            return Err(format!("perf failed: {}", stderr));
        }

        self.parse_perf_output(perf_data)
    }

    #[cfg(not(target_os = "linux"))]
    #[allow(dead_code)]
    fn profile_with_perf(&self, _binary: &str) -> Result<ProfileResult, String> {
        Err("perf is only available on Linux".to_string())
    }

    /// Profile using valgrind/callgrind (cross-platform)
    fn profile_with_valgrind(&self, binary: &str) -> Result<ProfileResult, String> {
        println!("🔍 Profiling with valgrind/callgrind...");

        let callgrind_file = "callgrind.out";

        let mut cmd = Command::new("valgrind");
        cmd.args([
            "--tool=callgrind",
            &format!("--callgrind-out-file={}", callgrind_file),
            binary,
        ]);

        println!(
            "Running: valgrind --tool=callgrind --callgrind-out-file={} {}",
            callgrind_file, binary
        );
        println!("Profiling until program exits (this may be slow)...");

        let output = cmd
            .output()
            .map_err(|e| format!("Failed to run valgrind: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "valgrind failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        // Show valgrind output
        let stderr = String::from_utf8_lossy(&output.stderr);
        if !stderr.is_empty() {
            println!("\n--- Valgrind Output ---");
            println!("{}", stderr);
            println!("--- End Output ---\n");
        }

        self.parse_callgrind_output(callgrind_file)
    }

    /// Check if perf is available
    #[cfg(target_os = "linux")]
    fn is_perf_available(&self) -> bool {
        Command::new("perf")
            .arg("--version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .is_ok()
    }

    #[cfg(not(target_os = "linux"))]
    #[allow(dead_code)]
    fn is_perf_available(&self) -> bool {
        false
    }

    /// Check if valgrind is available
    fn is_valgrind_available(&self) -> bool {
        Command::new("valgrind")
            .arg("--version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .is_ok()
    }

    /// Parse perf output
    #[cfg(target_os = "linux")]
    fn parse_perf_output(&self, perf_data: &str) -> Result<ProfileResult, String> {
        if !Path::new(perf_data).exists() {
            return Err("perf.data not generated. Profiling may have failed.".to_string());
        }

        let file_size = fs::metadata(perf_data).map(|m| m.len()).unwrap_or(0);

        let details = vec![
            "✓ Profiling completed successfully".to_string(),
            format!("📊 Profile data saved to: {}", perf_data),
            format!("   Size: {} bytes", file_size),
            "".to_string(),
            "To analyze the profile:".to_string(),
            "".to_string(),
            "1. Interactive report:".to_string(),
            "   perf report".to_string(),
            "".to_string(),
            "2. Generate flamegraph:".to_string(),
            "   perf script | stackcollapse-perf.pl | flamegraph.pl > flamegraph.svg".to_string(),
            "   (Requires: https://github.com/brendangregg/FlameGraph)".to_string(),
            "".to_string(),
            "3. Text report:".to_string(),
            "   perf report --stdio".to_string(),
            "".to_string(),
            "Profile contains:".to_string(),
            "  - CPU sampling data (99 Hz)".to_string(),
            "  - Call graphs with stack traces".to_string(),
            "  - Hot functions and paths".to_string(),
            "  - Hardware performance counters".to_string(),
        ];

        Ok(ProfileResult {
            language: "C++".to_string(),
            details,
        })
    }

    #[cfg(not(target_os = "linux"))]
    #[allow(dead_code)]
    fn parse_perf_output(&self, _perf_data: &str) -> Result<ProfileResult, String> {
        Err("perf is only available on Linux".to_string())
    }

    /// Parse callgrind output
    fn parse_callgrind_output(&self, callgrind_file: &str) -> Result<ProfileResult, String> {
        if !Path::new(callgrind_file).exists() {
            return Err("Callgrind file not generated. Profiling may have failed.".to_string());
        }

        let file_size = fs::metadata(callgrind_file).map(|m| m.len()).unwrap_or(0);

        // Try to extract basic stats
        let stats = self.analyze_callgrind(callgrind_file)?;

        let mut details = vec![
            "✓ Profiling completed successfully".to_string(),
            format!("📊 Callgrind file generated: {}", callgrind_file),
            format!("   Size: {} bytes", file_size),
            "".to_string(),
        ];

        details.extend(stats);

        details.extend(vec![
            "".to_string(),
            "To analyze the profile:".to_string(),
            "".to_string(),
            "1. Using KCacheGrind (Linux/macOS):".to_string(),
            format!("   kcachegrind {}", callgrind_file),
            "".to_string(),
            "2. Using QCacheGrind (macOS):".to_string(),
            "   brew install qcachegrind".to_string(),
            format!("   qcachegrind {}", callgrind_file),
            "".to_string(),
            "3. Text summary:".to_string(),
            format!("   callgrind_annotate {}", callgrind_file),
            "".to_string(),
            "Callgrind file contains:".to_string(),
            "  - Instruction counts per function".to_string(),
            "  - Call graph relationships".to_string(),
            "  - Cache simulation data".to_string(),
            "  - Branch prediction statistics".to_string(),
        ]);

        Ok(ProfileResult {
            language: "C++".to_string(),
            details,
        })
    }

    /// Analyze callgrind file for basic stats
    fn analyze_callgrind(&self, callgrind_file: &str) -> Result<Vec<String>, String> {
        let content = fs::read_to_string(callgrind_file)
            .map_err(|e| format!("Failed to read callgrind file: {}", e))?;

        let mut function_count = 0;
        let mut total_instructions = 0u64;

        for line in content.lines() {
            if line.starts_with("fn=") {
                function_count += 1;
            } else if !line.starts_with("#") && !line.starts_with("fl=") && !line.starts_with("fn=")
            {
                // Lines with instruction counts
                if let Some(count_str) = line.split_whitespace().last() {
                    if let Ok(count) = count_str.parse::<u64>() {
                        total_instructions += count;
                    }
                }
            }
        }

        Ok(vec![
            "Profile Statistics:".to_string(),
            format!("  - Functions profiled: {}", function_count),
            format!("  - Total instructions: {}", total_instructions),
        ])
    }

    /// Profile by attaching to PID
    pub fn profile_pid(&self, pid: u32) -> Result<ProfileResult, String> {
        println!("🔍 Attaching to C++ process PID: {}", pid);

        #[cfg(target_os = "linux")]
        {
            if !self.is_perf_available() {
                return Err(
                    "perf not found. Install with: apt-get install linux-tools-generic".to_string(),
                );
            }

            let perf_data = format!("perf_pid_{}.data", pid);

            let mut cmd = Command::new("perf");
            cmd.args([
                "record",
                "-F",
                "99",
                "-g",
                "-p",
                &pid.to_string(),
                "-o",
                &perf_data,
            ]);

            println!("Running: perf record -F 99 -g -p {} -o {}", pid, perf_data);
            println!("Press Ctrl+C to stop profiling...");

            let output = cmd
                .output()
                .map_err(|e| format!("Failed to run perf: {}", e))?;

            if !output.status.success() {
                let stderr = String::from_utf8_lossy(&output.stderr);

                if stderr.contains("permission") || stderr.contains("Operation not permitted") {
                    return Err("Permission denied. perf may require elevated privileges.\n\
                         Try: sudo sysctl kernel.perf_event_paranoid=0\n\
                         Or run with: sudo -E env PATH=$PATH <your command>"
                        .to_string());
                }

                return Err(format!("perf failed: {}", stderr));
            }

            self.parse_perf_output(&perf_data)
        }

        #[cfg(not(target_os = "linux"))]
        {
            Err("PID profiling for C++ is only supported on Linux (requires perf)".to_string())
        }
    }
}

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

    #[test]
    fn test_profiler_new() {
        let profiler = CppProfiler::new();
        assert_eq!(std::mem::size_of_val(&profiler), 0);
    }

    #[test]
    fn test_profiler_default() {
        let profiler = CppProfiler;
        assert_eq!(std::mem::size_of_val(&profiler), 0);
    }
}