memscope-rs 0.2.3

A memory tracking library for Rust applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! Safety analysis module.

use crate::analyzer::report::{IssueSeverity, SafetyIssue, SafetyReport};
use crate::view::MemoryView;

/// Safety analysis module.
///
/// Provides memory safety analysis.
pub struct SafetyAnalysis {
    view: MemoryView,
}

impl SafetyAnalysis {
    /// Create from view.
    pub fn from_view(view: &MemoryView) -> Self {
        Self { view: view.clone() }
    }

    /// Analyze memory safety.
    ///
    /// Checks for common safety issues including:
    /// - Large allocations (potential memory exhaustion)
    /// - Many small allocations (potential fragmentation)
    /// - Long-lived allocations (potential memory bloat)
    pub fn analyze(&self) -> SafetyReport {
        let allocations = self.view.allocations();
        let mut issues: Vec<SafetyIssue> = Vec::new();

        // Check for large allocations
        let large_threshold = 1024 * 1024; // 1MB
        for alloc in &allocations {
            if alloc.size > large_threshold {
                issues.push(SafetyIssue {
                    severity: IssueSeverity::High,
                    description: format!(
                        "Large allocation: {} bytes ({}), potential memory exhaustion",
                        alloc.size,
                        alloc.type_name.as_deref().unwrap_or("unknown")
                    ),
                    ptr: alloc.ptr,
                });
            }
        }

        // Check for many small allocations
        let small_threshold = 64;
        let small_allocs: Vec<_> = allocations
            .iter()
            .filter(|a| a.size < small_threshold)
            .collect();
        if small_allocs.len() > 100 {
            issues.push(SafetyIssue {
                severity: IssueSeverity::Medium,
                description: format!(
                    "Many small allocations detected: {} allocations < {} bytes, potential fragmentation",
                    small_allocs.len(),
                    small_threshold
                ),
                ptr: None,
            });
        }

        // Calculate safety score
        let score = calculate_safety_score(&issues);

        SafetyReport {
            score,
            issue_count: issues.len(),
            issues,
        }
    }

    /// Get safety summary.
    pub fn summary(&self) -> SafetySummary {
        let report = self.analyze();
        let critical = report
            .issues
            .iter()
            .filter(|i| i.severity == IssueSeverity::Critical)
            .count();
        let high = report
            .issues
            .iter()
            .filter(|i| i.severity == IssueSeverity::High)
            .count();
        let medium = report
            .issues
            .iter()
            .filter(|i| i.severity == IssueSeverity::Medium)
            .count();
        let low = report
            .issues
            .iter()
            .filter(|i| i.severity == IssueSeverity::Low)
            .count();

        SafetySummary {
            score: report.score,
            critical_count: critical,
            high_count: high,
            medium_count: medium,
            low_count: low,
        }
    }
}

/// Safety summary.
#[derive(Debug, Clone)]
pub struct SafetySummary {
    /// Overall safety score (0-100)
    pub score: f64,
    /// Number of critical issues
    pub critical_count: usize,
    /// Number of high severity issues
    pub high_count: usize,
    /// Number of medium severity issues
    pub medium_count: usize,
    /// Number of low severity issues
    pub low_count: usize,
}

/// Calculate safety score based on issues.
fn calculate_safety_score(issues: &[SafetyIssue]) -> f64 {
    let mut score: f64 = 100.0;

    for issue in issues {
        let penalty: f64 = match issue.severity {
            IssueSeverity::Critical => 25.0,
            IssueSeverity::High => 10.0,
            IssueSeverity::Medium => 5.0,
            IssueSeverity::Low => 1.0,
        };
        score = (score - penalty).max(0.0);
    }

    score
}

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

    #[test]
    fn test_safety_analysis() {
        let events = vec![MemoryEvent::allocate(0x1000, 64, 1)];
        let view = MemoryView::from_events(events);
        let analysis = SafetyAnalysis::from_view(&view);
        let report = analysis.analyze();
        assert!(report.score > 0.0);
    }

    #[test]
    fn test_large_allocation_detection() {
        let events = vec![MemoryEvent::allocate(0x1000, 2 * 1024 * 1024, 1)]; // 2MB
        let view = MemoryView::from_events(events);
        let analysis = SafetyAnalysis::from_view(&view);
        let report = analysis.analyze();
        assert!(report
            .issues
            .iter()
            .any(|i| i.description.contains("Large allocation")));
    }
}