torsh_autograd/

profiling_debugging_integration.rs

//! Profiling and Debugging Tools Integration
//!
//! This module provides integration with external profiling and debugging tools
//! for analyzing autograd operations, memory usage, and performance characteristics.
//! It supports various profilers, debuggers, and analysis tools.

// Framework infrastructure - components designed for future use
#![allow(dead_code)]
use crate::error_handling::{AutogradError, AutogradResult};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fmt;
use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};

/// External profiling tool types
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ProfilingTool {
    /// Linux perf profiler
    Perf,
    /// Intel VTune Profiler
    VTune,
    /// NVIDIA Nsight Systems
    NsightSystems,
    /// NVIDIA Nsight Compute
    NsightCompute,
    /// AMD uProf
    UProf,
    /// Apple Instruments
    Instruments,
    /// Google perftools (gperftools)
    GPerftools,
    /// Valgrind's callgrind
    Callgrind,
    /// Heaptrack memory profiler
    Heaptrack,
    /// Custom profiler
    Custom(String),
}

impl fmt::Display for ProfilingTool {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ProfilingTool::Perf => write!(f, "Linux perf"),
            ProfilingTool::VTune => write!(f, "Intel VTune"),
            ProfilingTool::NsightSystems => write!(f, "NVIDIA Nsight Systems"),
            ProfilingTool::NsightCompute => write!(f, "NVIDIA Nsight Compute"),
            ProfilingTool::UProf => write!(f, "AMD uProf"),
            ProfilingTool::Instruments => write!(f, "Apple Instruments"),
            ProfilingTool::GPerftools => write!(f, "Google perftools"),
            ProfilingTool::Callgrind => write!(f, "Valgrind Callgrind"),
            ProfilingTool::Heaptrack => write!(f, "Heaptrack"),
            ProfilingTool::Custom(name) => write!(f, "Custom({})", name),
        }
    }
}

/// Debugging tool types
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DebuggingTool {
    /// GNU Debugger (GDB)
    GDB,
    /// LLVM Debugger (LLDB)
    LLDB,
    /// Valgrind memory checker
    Valgrind,
    /// AddressSanitizer
    AddressSanitizer,
    /// ThreadSanitizer
    ThreadSanitizer,
    /// MemorySanitizer
    MemorySanitizer,
    /// Intel Inspector
    IntelInspector,
    /// CUDA memcheck
    CudaMemcheck,
    /// Custom debugger
    Custom(String),
}

impl fmt::Display for DebuggingTool {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DebuggingTool::GDB => write!(f, "GNU Debugger (GDB)"),
            DebuggingTool::LLDB => write!(f, "LLVM Debugger (LLDB)"),
            DebuggingTool::Valgrind => write!(f, "Valgrind"),
            DebuggingTool::AddressSanitizer => write!(f, "AddressSanitizer"),
            DebuggingTool::ThreadSanitizer => write!(f, "ThreadSanitizer"),
            DebuggingTool::MemorySanitizer => write!(f, "MemorySanitizer"),
            DebuggingTool::IntelInspector => write!(f, "Intel Inspector"),
            DebuggingTool::CudaMemcheck => write!(f, "CUDA memcheck"),
            DebuggingTool::Custom(name) => write!(f, "Custom({})", name),
        }
    }
}

/// Analysis capabilities provided by tools
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AnalysisCapability {
    /// CPU profiling and hotspot analysis
    CPUProfiling,
    /// Memory usage and leak detection
    MemoryAnalysis,
    /// GPU profiling and kernel analysis
    GPUProfiling,
    /// Thread synchronization analysis
    ThreadAnalysis,
    /// Cache performance analysis
    CacheAnalysis,
    /// Function call tracing
    CallTracing,
    /// Statistical sampling
    StatisticalSampling,
    /// Event-based profiling
    EventProfiling,
    /// Memory sanitization
    MemorySanitization,
    /// Race condition detection
    RaceDetection,
    /// Deadlock detection
    DeadlockDetection,
    /// Performance counter analysis
    PerformanceCounters,
    /// Hardware event monitoring
    HardwareEvents,
    /// Custom analysis
    Custom(String),
}

/// Profiling session configuration
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProfilingConfig {
    pub tool: ProfilingTool,
    pub output_directory: PathBuf,
    pub session_name: String,
    pub duration_limit: Option<Duration>,
    pub sampling_frequency: Option<u32>, // Hz
    pub cpu_events: Vec<String>,
    pub gpu_metrics: Vec<String>,
    pub memory_tracking: bool,
    pub call_stack_depth: Option<u32>,
    pub filter_functions: Vec<String>,
    pub custom_parameters: HashMap<String, String>,
}

impl Default for ProfilingConfig {
    fn default() -> Self {
        Self {
            tool: ProfilingTool::Perf,
            output_directory: std::env::temp_dir().join("autograd_profiling"),
            session_name: "autograd_session".to_string(),
            duration_limit: Some(Duration::from_secs(300)), // 5 minutes
            sampling_frequency: Some(1000),                 // 1 kHz
            cpu_events: vec!["cycles".to_string(), "instructions".to_string()],
            gpu_metrics: vec!["sm_efficiency".to_string(), "memory_throughput".to_string()],
            memory_tracking: true,
            call_stack_depth: Some(16),
            filter_functions: Vec::new(),
            custom_parameters: HashMap::new(),
        }
    }
}

/// Debugging session configuration
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DebuggingConfig {
    pub tool: DebuggingTool,
    pub attach_to_process: bool,
    pub core_dump_analysis: bool,
    pub memory_error_detection: bool,
    pub thread_error_detection: bool,
    pub break_on_error: bool,
    pub output_directory: PathBuf,
    pub log_level: LogLevel,
    pub custom_parameters: HashMap<String, String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum LogLevel {
    Error,
    Warning,
    Info,
    Debug,
    Trace,
}

impl Default for DebuggingConfig {
    fn default() -> Self {
        Self {
            tool: DebuggingTool::GDB,
            attach_to_process: false,
            core_dump_analysis: false,
            memory_error_detection: true,
            thread_error_detection: true,
            break_on_error: false,
            output_directory: std::env::temp_dir().join("autograd_debugging"),
            log_level: LogLevel::Info,
            custom_parameters: HashMap::new(),
        }
    }
}

/// Trait for external profiling tool integration
pub trait ExternalProfiler: Send + Sync + std::fmt::Debug {
    fn tool_type(&self) -> ProfilingTool;
    fn is_available(&self) -> bool;
    fn supported_capabilities(&self) -> Vec<AnalysisCapability>;

    fn start_profiling(&mut self, config: &ProfilingConfig) -> AutogradResult<ProfilingSession>;
    fn stop_profiling(&mut self, session: &ProfilingSession) -> AutogradResult<ProfilingReport>;
    fn annotate_operation(
        &self,
        session: &ProfilingSession,
        operation: &str,
        metadata: &HashMap<String, String>,
    ) -> AutogradResult<()>;
    fn create_checkpoint(&self, session: &ProfilingSession, name: &str) -> AutogradResult<()>;
}

/// Trait for external debugging tool integration
pub trait ExternalDebugger: Send + Sync + std::fmt::Debug {
    fn tool_type(&self) -> DebuggingTool;
    fn is_available(&self) -> bool;
    fn supported_capabilities(&self) -> Vec<AnalysisCapability>;

    fn start_debugging(&mut self, config: &DebuggingConfig) -> AutogradResult<DebuggingSession>;
    fn stop_debugging(&mut self, session: &DebuggingSession) -> AutogradResult<DebuggingReport>;
    fn set_breakpoint(&self, session: &DebuggingSession, location: &str) -> AutogradResult<()>;
    fn inspect_memory(
        &self,
        session: &DebuggingSession,
        address: usize,
        size: usize,
    ) -> AutogradResult<Vec<u8>>;
    fn analyze_stack_trace(&self, session: &DebuggingSession) -> AutogradResult<StackTrace>;
}

/// Profiling session handle
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProfilingSession {
    pub session_id: String,
    pub tool: ProfilingTool,
    pub start_time: std::time::SystemTime,
    pub config: ProfilingConfig,
    pub pid: Option<u32>,
}

/// Debugging session handle
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DebuggingSession {
    pub session_id: String,
    pub tool: DebuggingTool,
    pub start_time: std::time::SystemTime,
    pub config: DebuggingConfig,
    pub pid: Option<u32>,
}

/// Profiling report containing analysis results
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProfilingReport {
    pub session_id: String,
    pub tool: ProfilingTool,
    pub duration: Duration,
    pub cpu_profile: Option<CPUProfile>,
    pub memory_profile: Option<MemoryProfile>,
    pub gpu_profile: Option<GPUProfile>,
    pub call_graph: Option<CallGraph>,
    pub hotspots: Vec<Hotspot>,
    pub performance_counters: HashMap<String, u64>,
    pub annotations: Vec<OperationAnnotation>,
    pub raw_data_path: Option<PathBuf>,
}

/// Debugging report containing analysis results
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggingReport {
    pub session_id: String,
    pub tool: DebuggingTool,
    pub duration: Duration,
    pub memory_errors: Vec<MemoryError>,
    pub thread_errors: Vec<ThreadError>,
    pub stack_traces: Vec<StackTrace>,
    pub breakpoint_hits: Vec<BreakpointHit>,
    pub performance_impact: Option<f64>, // Overhead percentage
    pub raw_data_path: Option<PathBuf>,
}

/// CPU profiling data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CPUProfile {
    pub total_samples: u64,
    pub total_cpu_time: Duration,
    pub function_profiles: HashMap<String, FunctionProfile>,
    pub top_functions: Vec<(String, f64)>, // (function_name, percentage)
}

/// Memory profiling data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryProfile {
    pub peak_memory_usage: usize,
    pub total_allocations: u64,
    pub total_deallocations: u64,
    pub memory_leaks: Vec<MemoryLeak>,
    pub allocation_patterns: HashMap<String, AllocationPattern>,
}

/// GPU profiling data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GPUProfile {
    pub kernel_executions: Vec<KernelExecution>,
    pub memory_transfers: Vec<MemoryTransfer>,
    pub gpu_utilization: f64,    // Percentage
    pub memory_utilization: f64, // Percentage
    pub compute_efficiency: f64, // Percentage
}

/// Function profiling information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionProfile {
    pub name: String,
    pub call_count: u64,
    pub total_time: Duration,
    pub self_time: Duration,
    pub percentage: f64,
}

/// Memory allocation pattern
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AllocationPattern {
    pub allocation_size: usize,
    pub allocation_count: u64,
    pub deallocation_count: u64,
    pub average_lifetime: Duration,
}

/// Performance hotspot
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Hotspot {
    pub function: String,
    pub file: Option<String>,
    pub line: Option<u32>,
    pub cpu_percentage: f64,
    pub memory_usage: Option<usize>,
    pub call_count: u64,
}

/// Operation annotation for profiling
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OperationAnnotation {
    pub timestamp: std::time::SystemTime,
    pub operation: String,
    pub metadata: HashMap<String, String>,
    pub duration: Option<Duration>,
}

/// Call graph representation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CallGraph {
    pub nodes: Vec<CallGraphNode>,
    pub edges: Vec<CallGraphEdge>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CallGraphNode {
    pub id: usize,
    pub function: String,
    pub self_time: Duration,
    pub total_time: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CallGraphEdge {
    pub from: usize,
    pub to: usize,
    pub call_count: u64,
    pub time: Duration,
}

/// Memory error detected by debugging tools
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryError {
    pub error_type: MemoryErrorType,
    pub address: Option<usize>,
    pub size: Option<usize>,
    pub stack_trace: StackTrace,
    pub description: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MemoryErrorType {
    UseAfterFree,
    DoubleFree,
    MemoryLeak,
    BufferOverflow,
    BufferUnderflow,
    UninitializedRead,
    InvalidFree,
}

/// Thread error detected by debugging tools
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadError {
    pub error_type: ThreadErrorType,
    pub thread_ids: Vec<u32>,
    pub stack_traces: Vec<StackTrace>,
    pub description: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ThreadErrorType {
    DataRace,
    Deadlock,
    RaceCondition,
    InvalidLocking,
}

/// Stack trace information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StackTrace {
    pub frames: Vec<StackFrame>,
    pub thread_id: Option<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StackFrame {
    pub function: String,
    pub file: Option<String>,
    pub line: Option<u32>,
    pub address: Option<usize>,
}

/// Memory leak information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryLeak {
    pub size: usize,
    pub allocation_site: StackTrace,
    pub leak_probability: f64, // 0.0 to 1.0
}

/// Kernel execution information for GPU profiling
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KernelExecution {
    pub name: String,
    pub duration: Duration,
    pub grid_size: (u32, u32, u32),
    pub block_size: (u32, u32, u32),
    pub shared_memory: usize,
    pub registers_per_thread: u32,
    pub occupancy: f64,
}

/// GPU memory transfer information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryTransfer {
    pub direction: TransferDirection,
    pub size: usize,
    pub duration: Duration,
    pub bandwidth: f64, // GB/s
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TransferDirection {
    HostToDevice,
    DeviceToHost,
    DeviceToDevice,
}

/// Breakpoint hit information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BreakpointHit {
    pub location: String,
    pub hit_count: u32,
    pub stack_trace: StackTrace,
    pub timestamp: std::time::SystemTime,
}

/// Linux perf profiler implementation
#[derive(Debug)]
pub struct PerfProfiler {
    available: bool,
    active_sessions: HashMap<String, ProfilingSession>,
}

impl PerfProfiler {
    pub fn new() -> Self {
        let available = Command::new("perf")
            .arg("--version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .map(|status| status.success())
            .unwrap_or(false);

        Self {
            available,
            active_sessions: HashMap::new(),
        }
    }
}

impl ExternalProfiler for PerfProfiler {
    fn tool_type(&self) -> ProfilingTool {
        ProfilingTool::Perf
    }

    fn is_available(&self) -> bool {
        self.available
    }

    fn supported_capabilities(&self) -> Vec<AnalysisCapability> {
        vec![
            AnalysisCapability::CPUProfiling,
            AnalysisCapability::MemoryAnalysis,
            AnalysisCapability::CallTracing,
            AnalysisCapability::StatisticalSampling,
            AnalysisCapability::EventProfiling,
            AnalysisCapability::PerformanceCounters,
            AnalysisCapability::HardwareEvents,
        ]
    }

    fn start_profiling(&mut self, config: &ProfilingConfig) -> AutogradResult<ProfilingSession> {
        if !self.available {
            return Err(AutogradError::gradient_computation(
                "perf_availability",
                "perf profiler is not available on this system",
            ));
        }

        let session_id = format!(
            "perf_{}_{}",
            config.session_name,
            chrono::Utc::now().timestamp()
        );
        let pid = std::process::id();

        // Create output directory
        std::fs::create_dir_all(&config.output_directory).map_err(|e| {
            AutogradError::gradient_computation(
                "directory_creation",
                format!("Failed to create output directory: {}", e),
            )
        })?;

        let session = ProfilingSession {
            session_id: session_id.clone(),
            tool: ProfilingTool::Perf,
            start_time: std::time::SystemTime::now(),
            config: config.clone(),
            pid: Some(pid),
        };

        // Start perf recording (simulated)
        tracing::info!("Starting perf profiling session: {}", session_id);

        self.active_sessions
            .insert(session_id.clone(), session.clone());
        Ok(session)
    }

    fn stop_profiling(&mut self, session: &ProfilingSession) -> AutogradResult<ProfilingReport> {
        if !self.active_sessions.contains_key(&session.session_id) {
            return Err(AutogradError::gradient_computation(
                "profiling_session_lookup",
                "Profiling session not found",
            ));
        }

        let duration = session.start_time.elapsed().map_err(|e| {
            AutogradError::gradient_computation(
                "time_calculation",
                format!("Time calculation error: {}", e),
            )
        })?;

        // Generate mock profiling report
        let report = ProfilingReport {
            session_id: session.session_id.clone(),
            tool: ProfilingTool::Perf,
            duration,
            cpu_profile: Some(CPUProfile {
                total_samples: 10000,
                total_cpu_time: duration,
                function_profiles: {
                    let mut profiles = HashMap::new();
                    profiles.insert(
                        "autograd::backward".to_string(),
                        FunctionProfile {
                            name: "autograd::backward".to_string(),
                            call_count: 150,
                            total_time: Duration::from_millis(850),
                            self_time: Duration::from_millis(200),
                            percentage: 45.2,
                        },
                    );
                    profiles.insert(
                        "tensor::add".to_string(),
                        FunctionProfile {
                            name: "tensor::add".to_string(),
                            call_count: 300,
                            total_time: Duration::from_millis(600),
                            self_time: Duration::from_millis(600),
                            percentage: 32.1,
                        },
                    );
                    profiles
                },
                top_functions: vec![
                    ("autograd::backward".to_string(), 45.2),
                    ("tensor::add".to_string(), 32.1),
                    ("tensor::mul".to_string(), 22.7),
                ],
            }),
            memory_profile: Some(MemoryProfile {
                peak_memory_usage: 256 * 1024 * 1024, // 256MB
                total_allocations: 5000,
                total_deallocations: 4950,
                memory_leaks: vec![],
                allocation_patterns: HashMap::new(),
            }),
            gpu_profile: None, // perf doesn't directly support GPU profiling
            call_graph: None,
            hotspots: vec![Hotspot {
                function: "autograd::backward".to_string(),
                file: Some("src/autograd.rs".to_string()),
                line: Some(123),
                cpu_percentage: 45.2,
                memory_usage: Some(64 * 1024 * 1024),
                call_count: 150,
            }],
            performance_counters: {
                let mut counters = HashMap::new();
                counters.insert("cycles".to_string(), 1_500_000_000);
                counters.insert("instructions".to_string(), 800_000_000);
                counters.insert("cache-misses".to_string(), 250_000);
                counters
            },
            annotations: Vec::new(),
            raw_data_path: Some(
                session
                    .config
                    .output_directory
                    .join(format!("{}.data", session.session_id)),
            ),
        };

        self.active_sessions.remove(&session.session_id);
        tracing::info!("Stopped perf profiling session: {}", session.session_id);

        Ok(report)
    }

    fn annotate_operation(
        &self,
        session: &ProfilingSession,
        operation: &str,
        _metadata: &HashMap<String, String>,
    ) -> AutogradResult<()> {
        tracing::debug!(
            "Annotating operation '{}' in session {}",
            operation,
            session.session_id
        );
        // In a real implementation, this would add markers to the perf data
        Ok(())
    }

    fn create_checkpoint(&self, session: &ProfilingSession, name: &str) -> AutogradResult<()> {
        tracing::debug!(
            "Creating checkpoint '{}' in session {}",
            name,
            session.session_id
        );
        // In a real implementation, this would create a marker in the perf timeline
        Ok(())
    }
}

/// GDB debugger implementation
#[derive(Debug)]
pub struct GdbDebugger {
    available: bool,
    active_sessions: HashMap<String, DebuggingSession>,
}

impl GdbDebugger {
    pub fn new() -> Self {
        let available = Command::new("gdb")
            .arg("--version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .map(|status| status.success())
            .unwrap_or(false);

        Self {
            available,
            active_sessions: HashMap::new(),
        }
    }
}

impl ExternalDebugger for GdbDebugger {
    fn tool_type(&self) -> DebuggingTool {
        DebuggingTool::GDB
    }

    fn is_available(&self) -> bool {
        self.available
    }

    fn supported_capabilities(&self) -> Vec<AnalysisCapability> {
        vec![
            AnalysisCapability::CallTracing,
            AnalysisCapability::MemoryAnalysis,
            AnalysisCapability::ThreadAnalysis,
        ]
    }

    fn start_debugging(&mut self, config: &DebuggingConfig) -> AutogradResult<DebuggingSession> {
        if !self.available {
            return Err(AutogradError::gradient_computation(
                "gdb_availability",
                "GDB debugger is not available on this system",
            ));
        }

        let session_id = format!(
            "gdb_{}_{}",
            chrono::Utc::now().timestamp(),
            std::process::id()
        );
        let pid = if config.attach_to_process {
            Some(std::process::id())
        } else {
            None
        };

        let session = DebuggingSession {
            session_id: session_id.clone(),
            tool: DebuggingTool::GDB,
            start_time: std::time::SystemTime::now(),
            config: config.clone(),
            pid,
        };

        tracing::info!("Starting GDB debugging session: {}", session_id);
        self.active_sessions
            .insert(session_id.clone(), session.clone());

        Ok(session)
    }

    fn stop_debugging(&mut self, session: &DebuggingSession) -> AutogradResult<DebuggingReport> {
        if !self.active_sessions.contains_key(&session.session_id) {
            return Err(AutogradError::gradient_computation(
                "debugging_session_lookup",
                "Debugging session not found",
            ));
        }

        let duration = session.start_time.elapsed().map_err(|e| {
            AutogradError::gradient_computation(
                "time_calculation",
                format!("Time calculation error: {}", e),
            )
        })?;

        // Generate mock debugging report
        let report = DebuggingReport {
            session_id: session.session_id.clone(),
            tool: DebuggingTool::GDB,
            duration,
            memory_errors: Vec::new(), // GDB doesn't directly detect memory errors
            thread_errors: Vec::new(),
            stack_traces: vec![StackTrace {
                frames: vec![
                    StackFrame {
                        function: "autograd::backward".to_string(),
                        file: Some("src/autograd.rs".to_string()),
                        line: Some(123),
                        address: Some(0x7fff12345678),
                    },
                    StackFrame {
                        function: "tensor::add".to_string(),
                        file: Some("src/tensor.rs".to_string()),
                        line: Some(456),
                        address: Some(0x7fff12345600),
                    },
                ],
                thread_id: Some(1),
            }],
            breakpoint_hits: Vec::new(),
            performance_impact: Some(5.0), // 5% overhead
            raw_data_path: Some(
                session
                    .config
                    .output_directory
                    .join(format!("{}.log", session.session_id)),
            ),
        };

        self.active_sessions.remove(&session.session_id);
        tracing::info!("Stopped GDB debugging session: {}", session.session_id);

        Ok(report)
    }

    fn set_breakpoint(&self, session: &DebuggingSession, location: &str) -> AutogradResult<()> {
        tracing::debug!(
            "Setting breakpoint at '{}' in session {}",
            location,
            session.session_id
        );
        // In a real implementation, this would interact with GDB to set the breakpoint
        Ok(())
    }

    fn inspect_memory(
        &self,
        session: &DebuggingSession,
        address: usize,
        size: usize,
    ) -> AutogradResult<Vec<u8>> {
        tracing::debug!(
            "Inspecting memory at 0x{:x} ({} bytes) in session {}",
            address,
            size,
            session.session_id
        );
        // Return mock memory data
        Ok(vec![0u8; size])
    }

    fn analyze_stack_trace(&self, session: &DebuggingSession) -> AutogradResult<StackTrace> {
        tracing::debug!("Analyzing stack trace in session {}", session.session_id);
        Ok(StackTrace {
            frames: vec![StackFrame {
                function: "current_function".to_string(),
                file: Some("src/current.rs".to_string()),
                line: Some(42),
                address: Some(0x7fff87654321),
            }],
            thread_id: Some(1),
        })
    }
}

/// Profiling and debugging integration manager
pub struct ProfilingDebuggingManager {
    profilers: HashMap<ProfilingTool, Box<dyn ExternalProfiler>>,
    debuggers: HashMap<DebuggingTool, Box<dyn ExternalDebugger>>,
    active_profiling_sessions: HashMap<String, ProfilingSession>,
    active_debugging_sessions: HashMap<String, DebuggingSession>,
    config: IntegrationConfig,
}

/// Integration configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IntegrationConfig {
    pub auto_detect_tools: bool,
    pub preferred_profiler: Option<ProfilingTool>,
    pub preferred_debugger: Option<DebuggingTool>,
    pub enable_continuous_profiling: bool,
    pub profile_threshold_ms: u64,  // Minimum operation time to profile
    pub memory_threshold_mb: usize, // Minimum memory usage to profile
    pub output_base_directory: PathBuf,
}

impl Default for IntegrationConfig {
    fn default() -> Self {
        Self {
            auto_detect_tools: true,
            preferred_profiler: None,
            preferred_debugger: None,
            enable_continuous_profiling: false,
            profile_threshold_ms: 100, // Profile operations > 100ms
            memory_threshold_mb: 100,  // Profile if using > 100MB
            output_base_directory: std::env::temp_dir().join("autograd_analysis"),
        }
    }
}

impl ProfilingDebuggingManager {
    pub fn new(config: IntegrationConfig) -> Self {
        Self {
            profilers: HashMap::new(),
            debuggers: HashMap::new(),
            active_profiling_sessions: HashMap::new(),
            active_debugging_sessions: HashMap::new(),
            config,
        }
    }

    pub fn with_default_config() -> Self {
        Self::new(IntegrationConfig::default())
    }

    pub fn initialize(&mut self) -> AutogradResult<()> {
        if self.config.auto_detect_tools {
            self.detect_and_register_tools()?;
        }

        // Create output directory
        std::fs::create_dir_all(&self.config.output_base_directory).map_err(|e| {
            AutogradError::gradient_computation(
                "directory_creation",
                format!("Failed to create output directory: {}", e),
            )
        })?;

        tracing::info!("Profiling and debugging integration manager initialized");
        Ok(())
    }

    fn detect_and_register_tools(&mut self) -> AutogradResult<()> {
        // Register profilers
        let perf_profiler = Box::new(PerfProfiler::new());
        if perf_profiler.is_available() {
            self.profilers.insert(ProfilingTool::Perf, perf_profiler);
            tracing::info!("Registered perf profiler");
        }

        // Register debuggers
        let gdb_debugger = Box::new(GdbDebugger::new());
        if gdb_debugger.is_available() {
            self.debuggers.insert(DebuggingTool::GDB, gdb_debugger);
            tracing::info!("Registered GDB debugger");
        }

        tracing::info!(
            "Detected {} profilers and {} debuggers",
            self.profilers.len(),
            self.debuggers.len()
        );

        Ok(())
    }

    pub fn list_available_profilers(&self) -> Vec<ProfilingTool> {
        self.profilers.keys().cloned().collect()
    }

    pub fn list_available_debuggers(&self) -> Vec<DebuggingTool> {
        self.debuggers.keys().cloned().collect()
    }

    pub fn start_profiling_session(
        &mut self,
        mut config: ProfilingConfig,
    ) -> AutogradResult<ProfilingSession> {
        // Override output directory if not set
        if config.output_directory == std::env::temp_dir().join("autograd_profiling") {
            config.output_directory = self.config.output_base_directory.join("profiling");
        }

        let profiler = self.profilers.get_mut(&config.tool).ok_or_else(|| {
            AutogradError::gradient_computation(
                "profiler_lookup",
                format!("Profiler {} not available", config.tool),
            )
        })?;

        let session = profiler.start_profiling(&config)?;
        self.active_profiling_sessions
            .insert(session.session_id.clone(), session.clone());

        tracing::info!(
            "Started profiling session: {} with {}",
            session.session_id,
            config.tool
        );
        Ok(session)
    }

    pub fn stop_profiling_session(&mut self, session_id: &str) -> AutogradResult<ProfilingReport> {
        let session = self
            .active_profiling_sessions
            .remove(session_id)
            .ok_or_else(|| {
                AutogradError::gradient_computation(
                    "profiling_session_removal",
                    format!("Profiling session {} not found", session_id),
                )
            })?;

        let profiler = self.profilers.get_mut(&session.tool).ok_or_else(|| {
            AutogradError::gradient_computation(
                "profiler_session_stop",
                format!("Profiler {} not available", session.tool),
            )
        })?;

        let report = profiler.stop_profiling(&session)?;
        tracing::info!("Stopped profiling session: {}", session_id);

        Ok(report)
    }

    pub fn start_debugging_session(
        &mut self,
        mut config: DebuggingConfig,
    ) -> AutogradResult<DebuggingSession> {
        // Override output directory if not set
        if config.output_directory == std::env::temp_dir().join("autograd_debugging") {
            config.output_directory = self.config.output_base_directory.join("debugging");
        }

        let debugger = self.debuggers.get_mut(&config.tool).ok_or_else(|| {
            AutogradError::gradient_computation(
                "debugger_lookup",
                format!("Debugger {} not available", config.tool),
            )
        })?;

        let session = debugger.start_debugging(&config)?;
        self.active_debugging_sessions
            .insert(session.session_id.clone(), session.clone());

        tracing::info!(
            "Started debugging session: {} with {}",
            session.session_id,
            config.tool
        );
        Ok(session)
    }

    pub fn stop_debugging_session(&mut self, session_id: &str) -> AutogradResult<DebuggingReport> {
        let session = self
            .active_debugging_sessions
            .remove(session_id)
            .ok_or_else(|| {
                AutogradError::gradient_computation(
                    "debugging_session_removal",
                    format!("Debugging session {} not found", session_id),
                )
            })?;

        let debugger = self.debuggers.get_mut(&session.tool).ok_or_else(|| {
            AutogradError::gradient_computation(
                "debugger_session_stop",
                format!("Debugger {} not available", session.tool),
            )
        })?;

        let report = debugger.stop_debugging(&session)?;
        tracing::info!("Stopped debugging session: {}", session_id);

        Ok(report)
    }

    pub fn profile_operation<F, T>(
        &mut self,
        operation_name: &str,
        operation: F,
    ) -> AutogradResult<(T, Option<ProfilingReport>)>
    where
        F: FnOnce() -> AutogradResult<T>,
    {
        if !self.config.enable_continuous_profiling {
            let result = operation()?;
            return Ok((result, None));
        }

        // Start profiling if we have a preferred profiler
        let profiling_session = if let Some(preferred_tool) = &self.config.preferred_profiler {
            let mut config = ProfilingConfig::default();
            config.tool = preferred_tool.clone();
            config.session_name = format!("auto_{}", operation_name);
            config.duration_limit = Some(Duration::from_secs(60));

            self.start_profiling_session(config).ok()
        } else {
            None
        };

        let start_time = Instant::now();
        let result = operation()?;
        let duration = start_time.elapsed();

        // Stop profiling if we started it and the operation was significant
        let report = if let Some(session) = profiling_session {
            if duration.as_millis() > self.config.profile_threshold_ms as u128 {
                self.stop_profiling_session(&session.session_id).ok()
            } else {
                // Operation was too fast, stop profiling but don't return report
                let _ = self.stop_profiling_session(&session.session_id);
                None
            }
        } else {
            None
        };

        Ok((result, report))
    }

    pub fn get_integration_report(&self) -> IntegrationReport {
        IntegrationReport {
            available_profilers: self.list_available_profilers(),
            available_debuggers: self.list_available_debuggers(),
            active_profiling_sessions: self.active_profiling_sessions.len(),
            active_debugging_sessions: self.active_debugging_sessions.len(),
            config: self.config.clone(),
        }
    }
}

/// Integration status report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IntegrationReport {
    pub available_profilers: Vec<ProfilingTool>,
    pub available_debuggers: Vec<DebuggingTool>,
    pub active_profiling_sessions: usize,
    pub active_debugging_sessions: usize,
    pub config: IntegrationConfig,
}

impl IntegrationReport {
    pub fn print_summary(&self) {
        println!("=== Profiling and Debugging Integration Report ===");
        println!("Available Profilers: {:?}", self.available_profilers);
        println!("Available Debuggers: {:?}", self.available_debuggers);
        println!(
            "Active Profiling Sessions: {}",
            self.active_profiling_sessions
        );
        println!(
            "Active Debugging Sessions: {}",
            self.active_debugging_sessions
        );
        println!(
            "Continuous Profiling: {}",
            self.config.enable_continuous_profiling
        );
        println!();
    }
}

/// Global profiling and debugging integration manager
static GLOBAL_PROFILING_DEBUGGING_MANAGER: std::sync::OnceLock<
    std::sync::Mutex<ProfilingDebuggingManager>,
> = std::sync::OnceLock::new();

pub fn get_global_profiling_debugging_manager(
) -> &'static std::sync::Mutex<ProfilingDebuggingManager> {
    GLOBAL_PROFILING_DEBUGGING_MANAGER.get_or_init(|| {
        let mut manager = ProfilingDebuggingManager::with_default_config();
        if let Err(e) = manager.initialize() {
            tracing::error!(
                "Failed to initialize profiling and debugging manager: {}",
                e
            );
        }
        std::sync::Mutex::new(manager)
    })
}

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

    #[test]
    fn test_profiling_tool_display() {
        assert_eq!(ProfilingTool::Perf.to_string(), "Linux perf");
        assert_eq!(ProfilingTool::VTune.to_string(), "Intel VTune");
        assert_eq!(
            ProfilingTool::Custom("test".to_string()).to_string(),
            "Custom(test)"
        );
    }

    #[test]
    fn test_debugging_tool_display() {
        assert_eq!(DebuggingTool::GDB.to_string(), "GNU Debugger (GDB)");
        assert_eq!(DebuggingTool::Valgrind.to_string(), "Valgrind");
    }

    #[test]
    fn test_profiling_config() {
        let config = ProfilingConfig::default();
        assert_eq!(config.tool, ProfilingTool::Perf);
        assert!(config.memory_tracking);
        assert_eq!(config.sampling_frequency, Some(1000));
    }

    #[test]
    fn test_debugging_config() {
        let config = DebuggingConfig::default();
        assert_eq!(config.tool, DebuggingTool::GDB);
        assert!(config.memory_error_detection);
        assert_eq!(config.log_level, LogLevel::Info);
    }

    #[test]
    fn test_profiling_session() {
        let config = ProfilingConfig::default();
        let session = ProfilingSession {
            session_id: "test_session".to_string(),
            tool: ProfilingTool::Perf,
            start_time: std::time::SystemTime::now(),
            config,
            pid: Some(12345),
        };

        assert_eq!(session.session_id, "test_session");
        assert_eq!(session.tool, ProfilingTool::Perf);
    }

    #[test]
    fn test_perf_profiler() {
        let profiler = PerfProfiler::new();
        assert_eq!(profiler.tool_type(), ProfilingTool::Perf);

        let capabilities = profiler.supported_capabilities();
        assert!(capabilities.contains(&AnalysisCapability::CPUProfiling));
        assert!(capabilities.contains(&AnalysisCapability::MemoryAnalysis));
    }

    #[test]
    fn test_gdb_debugger() {
        let debugger = GdbDebugger::new();
        assert_eq!(debugger.tool_type(), DebuggingTool::GDB);

        let capabilities = debugger.supported_capabilities();
        assert!(capabilities.contains(&AnalysisCapability::CallTracing));
        assert!(capabilities.contains(&AnalysisCapability::MemoryAnalysis));
    }

    #[test]
    fn test_memory_error_types() {
        let error = MemoryError {
            error_type: MemoryErrorType::UseAfterFree,
            address: Some(0x12345678),
            size: Some(64),
            stack_trace: StackTrace {
                frames: vec![],
                thread_id: Some(1),
            },
            description: "Use after free detected".to_string(),
        };

        assert_eq!(error.address, Some(0x12345678));
        assert_eq!(error.size, Some(64));
    }

    #[test]
    fn test_stack_trace() {
        let trace = StackTrace {
            frames: vec![
                StackFrame {
                    function: "main".to_string(),
                    file: Some("src/main.rs".to_string()),
                    line: Some(10),
                    address: Some(0x1000),
                },
                StackFrame {
                    function: "foo".to_string(),
                    file: Some("src/lib.rs".to_string()),
                    line: Some(42),
                    address: Some(0x2000),
                },
            ],
            thread_id: Some(1),
        };

        assert_eq!(trace.frames.len(), 2);
        assert_eq!(trace.frames[0].function, "main");
        assert_eq!(trace.frames[1].line, Some(42));
    }

    #[test]
    fn test_integration_config() {
        let config = IntegrationConfig::default();
        assert!(config.auto_detect_tools);
        assert_eq!(config.profile_threshold_ms, 100);
        assert_eq!(config.memory_threshold_mb, 100);
    }

    #[test]
    fn test_profiling_debugging_manager() {
        let config = IntegrationConfig::default();
        let manager = ProfilingDebuggingManager::new(config);

        // Should start empty until initialized
        assert!(manager.list_available_profilers().is_empty());
        assert!(manager.list_available_debuggers().is_empty());
    }

    #[test]
    fn test_kernel_execution() {
        let kernel = KernelExecution {
            name: "test_kernel".to_string(),
            duration: Duration::from_millis(5),
            grid_size: (64, 1, 1),
            block_size: (256, 1, 1),
            shared_memory: 1024,
            registers_per_thread: 32,
            occupancy: 0.8,
        };

        assert_eq!(kernel.name, "test_kernel");
        assert_eq!(kernel.grid_size, (64, 1, 1));
        assert_eq!(kernel.occupancy, 0.8);
    }

    #[test]
    fn test_log_level() {
        assert_eq!(LogLevel::Info, LogLevel::Info);
        assert_ne!(LogLevel::Debug, LogLevel::Error);
    }

    #[test]
    fn test_transfer_direction() {
        let transfer = MemoryTransfer {
            direction: TransferDirection::HostToDevice,
            size: 1024 * 1024, // 1MB
            duration: Duration::from_millis(2),
            bandwidth: 500.0, // 500 GB/s
        };

        assert_eq!(transfer.size, 1024 * 1024);
        assert_eq!(transfer.bandwidth, 500.0);
    }
}