ryo_analysis/query/

lock_analyzer_v2.rs

//! LockGranularityAnalyzerV2 - VarId-based lock granularity analysis.
//!
//! Key improvements over V1:
//! - Uses VarId instead of petgraph::NodeIndex
//! - Integrates with LockTrackerV2

use std::cmp::Reverse;

use super::{AccessKind, CriticalSectionV2, LockSuggestion, LockTrackerV2, LockType};

/// Lightweight lock granularity analyzer using LockTrackerV2 (V2 - uses VarId).
///
/// This analyzer detects:
/// - Coarse-grained locks that can be split
/// - Critical sections that are too wide
/// - Mutex that can be replaced with RwLock
/// - Locks held across await points
pub struct LockGranularityAnalyzerV2<'a> {
    tracker: &'a LockTrackerV2,
}

impl<'a> LockGranularityAnalyzerV2<'a> {
    /// Create a new analyzer.
    pub fn new(tracker: &'a LockTrackerV2) -> Self {
        Self { tracker }
    }

    /// Analyze all critical sections and generate suggestions.
    pub fn analyze(&self) -> Vec<LockSuggestion> {
        let mut suggestions = Vec::new();

        for cs in self.tracker.critical_sections() {
            suggestions.extend(self.analyze_critical_section(cs));
        }

        // Sort by severity (most important first)
        suggestions.sort_by_key(|b| Reverse(b.severity()));
        suggestions
    }

    /// Analyze a single critical section.
    fn analyze_critical_section(&self, cs: &CriticalSectionV2) -> Vec<LockSuggestion> {
        let mut suggestions = Vec::new();

        // Check for await in async lock
        if cs.contains_await {
            suggestions.push(LockSuggestion::LockAcrossAwait {
                guard_name: cs.acquisition.guard_name.clone(),
                lock_line: cs.acquisition.line,
                await_line: cs.start_line, // Approximate
            });
        }

        // Check for atomic opportunity
        suggestions.extend(self.check_atomic_opportunity(cs));

        // Check for split lock opportunity
        if let Some(split) = self.check_split_opportunity(cs) {
            suggestions.push(split);
        }

        // Check for RwLock opportunity
        if let Some(rwlock) = self.check_rwlock_opportunity(cs) {
            suggestions.push(rwlock);
        }

        // Check for scope reduction
        if let Some(reduce) = self.check_scope_reduction(cs) {
            suggestions.push(reduce);
        }

        suggestions
    }

    /// Check if a field can be replaced with atomic type.
    fn check_atomic_opportunity(&self, cs: &CriticalSectionV2) -> Vec<LockSuggestion> {
        let mut suggestions = Vec::new();
        let unique_fields = cs.unique_fields();

        // If only one field is accessed, it might be a candidate for atomic
        if unique_fields.len() == 1 {
            let field = unique_fields[0];
            let access_kind = cs.field_access_kind(field);

            // Simple heuristic: if field name suggests a counter/flag
            let suggested_type = self.suggest_atomic_type(field, access_kind);

            if let Some(atomic_type) = suggested_type {
                suggestions.push(LockSuggestion::UseAtomic {
                    field: field.to_string(),
                    current_type: None,
                    suggested_type: atomic_type,
                    line: cs.start_line,
                });
            }
        }

        suggestions
    }

    /// Suggest an atomic type based on field name and access pattern.
    fn suggest_atomic_type(&self, field: &str, _access_kind: Option<AccessKind>) -> Option<String> {
        let field_lower = field.to_lowercase();

        // Counter-like fields
        if field_lower.contains("count")
            || field_lower.contains("counter")
            || field_lower.contains("num")
            || field_lower.contains("total")
            || field_lower.contains("size")
            || field_lower.contains("len")
        {
            return Some("AtomicUsize".to_string());
        }

        // Flag-like fields
        if field_lower.contains("flag")
            || field_lower.contains("enabled")
            || field_lower.contains("active")
            || field_lower.contains("ready")
            || field_lower.contains("done")
            || field_lower.contains("is_")
        {
            return Some("AtomicBool".to_string());
        }

        // ID-like fields
        if field_lower.contains("id")
            || field_lower.contains("index")
            || field_lower.contains("seq")
        {
            return Some("AtomicU64".to_string());
        }

        None
    }

    /// Check if lock can be split into multiple finer locks.
    fn check_split_opportunity(&self, cs: &CriticalSectionV2) -> Option<LockSuggestion> {
        let unique_fields = cs.unique_fields();

        // Need at least 2 fields to consider splitting
        if unique_fields.len() < 2 {
            return None;
        }

        // Check if fields have different access patterns
        let mut suggested_splits = Vec::new();

        for field in unique_fields {
            let access_kind = cs.field_access_kind(field);
            let wrapper = match access_kind {
                Some(AccessKind::Read) => "Arc<RwLock<_>>".to_string(),
                Some(AccessKind::Write) | Some(AccessKind::ReadWrite) => {
                    "Arc<Mutex<_>>".to_string()
                }
                None => continue,
            };
            suggested_splits.push((field.to_string(), wrapper));
        }

        if suggested_splits.len() >= 2 {
            Some(LockSuggestion::SplitLock {
                lock_name: cs.acquisition.lock_name.clone(),
                suggested_splits,
                line: cs.acquisition.line,
            })
        } else {
            None
        }
    }

    /// Check if Mutex can be replaced with RwLock.
    fn check_rwlock_opportunity(&self, cs: &CriticalSectionV2) -> Option<LockSuggestion> {
        // Only suggest for Mutex (not already RwLock)
        if !matches!(
            cs.acquisition.lock_type,
            LockType::Mutex | LockType::ParkingLotMutex | LockType::TokioMutex
        ) {
            return None;
        }

        let mut read_count = 0;
        let mut write_count = 0;

        for access in &cs.field_accesses {
            match access.access_kind {
                AccessKind::Read => read_count += 1,
                AccessKind::Write => write_count += 1,
                AccessKind::ReadWrite => {
                    read_count += 1;
                    write_count += 1;
                }
            }
        }

        // Suggest RwLock if reads significantly outnumber writes
        if read_count > write_count * 2 && read_count >= 3 {
            Some(LockSuggestion::UseRwLock {
                lock_name: cs.acquisition.lock_name.clone(),
                read_count,
                write_count,
                line: cs.acquisition.line,
            })
        } else {
            None
        }
    }

    /// Check if critical section scope can be reduced.
    fn check_scope_reduction(&self, cs: &CriticalSectionV2) -> Option<LockSuggestion> {
        let end_line = cs.end_line?;
        let span = end_line.saturating_sub(cs.start_line);

        // If CS is large and contains expensive ops, suggest reduction
        if span > 5 && cs.contains_expensive_ops {
            // Find the actual usage range
            let first_access = cs.field_accesses.iter().map(|a| a.line).min()?;
            let last_access = cs.field_accesses.iter().map(|a| a.line).max()?;

            // If there's significant gap between lock and first use, or last use and unlock
            if first_access > cs.start_line + 2 || end_line > last_access + 2 {
                return Some(LockSuggestion::ReduceScope {
                    guard_name: cs.acquisition.guard_name.clone(),
                    current_span: (cs.start_line, end_line),
                    suggested_span: (first_access.saturating_sub(1), last_access + 1),
                    reason: "lock held across non-critical operations".to_string(),
                });
            }
        }

        None
    }

    /// Get lock statistics.
    pub fn stats(&self) -> LockStatsV2 {
        let sections = self.tracker.critical_sections();

        let mut mutex_count = 0;
        let mut rwlock_count = 0;
        let mut refcell_count = 0;
        let mut total_field_accesses = 0;
        let mut max_cs_span = 0u32;

        for cs in sections {
            match cs.acquisition.lock_type {
                LockType::Mutex | LockType::ParkingLotMutex | LockType::TokioMutex => {
                    mutex_count += 1
                }
                LockType::RwLockRead
                | LockType::RwLockWrite
                | LockType::ParkingLotRwLock
                | LockType::TokioRwLock => rwlock_count += 1,
                LockType::RefCell | LockType::RefCellMut => refcell_count += 1,
            }

            total_field_accesses += cs.field_accesses.len();

            if let Some(span) = cs.span() {
                max_cs_span = max_cs_span.max(span);
            }
        }

        LockStatsV2 {
            total_locks: sections.len(),
            mutex_count,
            rwlock_count,
            refcell_count,
            total_field_accesses,
            max_cs_span,
        }
    }

    /// Get the underlying LockTrackerV2.
    pub fn tracker(&self) -> &LockTrackerV2 {
        self.tracker
    }
}

/// Statistics about lock usage (V2).
#[derive(Debug, Clone, Default)]
pub struct LockStatsV2 {
    /// Total number of lock acquisitions.
    pub total_locks: usize,
    /// Number of Mutex locks.
    pub mutex_count: usize,
    /// Number of RwLock locks.
    pub rwlock_count: usize,
    /// Number of RefCell borrows.
    pub refcell_count: usize,
    /// Total field accesses within critical sections.
    pub total_field_accesses: usize,
    /// Maximum critical section span (lines).
    pub max_cs_span: u32,
}

#[cfg(test)]
mod tests {
    use super::super::{LockAcquisitionV2, VarSymbolMapping};
    use super::*;
    use crate::symbol::SymbolId;
    use crate::VarId;
    use slotmap::SlotMap;

    /// Test helper to create VarIds from a shared mapping.
    struct TestVars {
        symbols: SlotMap<SymbolId, &'static str>,
        mapping: VarSymbolMapping,
    }

    impl TestVars {
        fn new() -> Self {
            Self {
                symbols: SlotMap::with_key(),
                mapping: VarSymbolMapping::new(),
            }
        }

        fn var(&mut self, name: &'static str) -> VarId {
            let sym = self.symbols.insert(name);
            self.mapping.register(sym)
        }
    }

    #[test]
    fn test_atomic_suggestion_counter() {
        let mut tracker = LockTrackerV2::new();
        let mut vars = TestVars::new();

        let lock_var = vars.var("lock");
        let guard_var = vars.var("guard");

        // Acquire lock
        tracker.acquire(LockAcquisitionV2::new(
            lock_var,
            guard_var,
            LockType::Mutex,
            10,
            "mutex",
            "guard",
        ));

        // Access only 'counter' field
        tracker.record_field_access(guard_var, "counter", AccessKind::Write, 11);

        // Release lock
        tracker.release(guard_var, 15);

        let analyzer = LockGranularityAnalyzerV2::new(&tracker);
        let suggestions = analyzer.analyze();

        assert!(suggestions
            .iter()
            .any(|s| matches!(s, LockSuggestion::UseAtomic { field, .. } if field == "counter")));
    }

    #[test]
    fn test_rwlock_suggestion() {
        let mut tracker = LockTrackerV2::new();
        let mut vars = TestVars::new();

        let lock_var = vars.var("lock");
        let guard_var = vars.var("guard");

        tracker.acquire(LockAcquisitionV2::new(
            lock_var,
            guard_var,
            LockType::Mutex,
            10,
            "cache",
            "guard",
        ));

        // Many reads, few writes
        tracker.record_field_access(guard_var, "data", AccessKind::Read, 11);
        tracker.record_field_access(guard_var, "data", AccessKind::Read, 12);
        tracker.record_field_access(guard_var, "data", AccessKind::Read, 13);
        tracker.record_field_access(guard_var, "data", AccessKind::Read, 14);
        tracker.record_field_access(guard_var, "data", AccessKind::Write, 15);

        tracker.release(guard_var, 20);

        let analyzer = LockGranularityAnalyzerV2::new(&tracker);
        let suggestions = analyzer.analyze();

        assert!(suggestions.iter().any(
            |s| matches!(s, LockSuggestion::UseRwLock { read_count, write_count, .. }
                if *read_count == 4 && *write_count == 1)
        ));
    }

    #[test]
    fn test_split_lock_suggestion() {
        let mut tracker = LockTrackerV2::new();
        let mut vars = TestVars::new();

        let lock_var = vars.var("lock");
        let guard_var = vars.var("guard");

        tracker.acquire(LockAcquisitionV2::new(
            lock_var,
            guard_var,
            LockType::Mutex,
            10,
            "state",
            "guard",
        ));

        // Access multiple independent fields
        tracker.record_field_access(guard_var, "counter", AccessKind::Write, 11);
        tracker.record_field_access(guard_var, "name", AccessKind::Read, 12);
        tracker.record_field_access(guard_var, "config", AccessKind::Read, 13);

        tracker.release(guard_var, 20);

        let analyzer = LockGranularityAnalyzerV2::new(&tracker);
        let suggestions = analyzer.analyze();

        assert!(suggestions.iter().any(
            |s| matches!(s, LockSuggestion::SplitLock { suggested_splits, .. }
                if suggested_splits.len() == 3)
        ));
    }

    #[test]
    fn test_lock_stats() {
        let mut tracker = LockTrackerV2::new();
        let mut vars = TestVars::new();

        let lock1 = vars.var("lock1");
        let guard1 = vars.var("guard1");
        let lock2 = vars.var("lock2");
        let guard2 = vars.var("guard2");

        // Add two locks
        tracker.acquire(LockAcquisitionV2::new(
            lock1,
            guard1,
            LockType::Mutex,
            10,
            "m1",
            "g1",
        ));
        tracker.record_field_access(guard1, "field1", AccessKind::Write, 11);
        tracker.release(guard1, 15);

        tracker.acquire(LockAcquisitionV2::new(
            lock2,
            guard2,
            LockType::RwLockRead,
            20,
            "r1",
            "g2",
        ));
        tracker.record_field_access(guard2, "field2", AccessKind::Read, 21);
        tracker.release(guard2, 25);

        let analyzer = LockGranularityAnalyzerV2::new(&tracker);
        let stats = analyzer.stats();

        assert_eq!(stats.total_locks, 2);
        assert_eq!(stats.mutex_count, 1);
        assert_eq!(stats.rwlock_count, 1);
        assert_eq!(stats.total_field_accesses, 2);
    }
}