pmat 3.11.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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

// CudaSimdAnalyzer directory traversal, path filtering, and file dispatch

impl CudaSimdAnalyzer {
    /// Directories to skip during analysis (common ignore patterns)
    const IGNORED_DIRS: &'static [&'static str] = &[
        ".venv", "venv", "node_modules", "target", ".git", "__pycache__",
        ".tox", ".nox", "dist", "build", ".eggs", "*.egg-info",
        ".mypy_cache", ".pytest_cache", ".cargo", "vendor",
    ];

    /// Check if a path should be skipped (in an ignored directory)
    fn should_skip_path(path: &Path) -> bool {
        for component in path.components() {
            if let std::path::Component::Normal(name) = component {
                let name_str = name.to_string_lossy();
                for ignored in Self::IGNORED_DIRS {
                    if name_str == *ignored || name_str.ends_with(".egg-info") {
                        return true;
                    }
                }
            }
        }
        false
    }

    fn analyze_directory(
        &self,
        path: &Path,
        defects: &mut Vec<DetectedDefect>,
        cuda_files: &mut usize,
        simd_files: &mut usize,
        wgpu_files: &mut usize,
        files_analyzed: &mut usize,
        barrier_safety: &mut BarrierSafetyResult,
        coalescing: &mut CoalescingResult,
    ) -> anyhow::Result<()> {
        for entry in walkdir::WalkDir::new(path)
            .follow_links(true)
            .into_iter()
            .filter_entry(|e| !Self::should_skip_path(e.path()))
            .filter_map(Result::ok)
        {
            let file_path = entry.path();
            if file_path.is_file() {
                if let Some(ext) = file_path.extension() {
                    let ext_str = ext.to_string_lossy().to_lowercase();
                    if matches!(
                        ext_str.as_str(),
                        "cu" | "cuh" | "ptx" | "rs" | "wgsl" | "c" | "cpp" | "h" | "hpp"
                    ) {
                        if let Ok(analysis) = self.analyze_file(file_path) {
                            *files_analyzed += 1;
                            *cuda_files += analysis.cuda_files;
                            *simd_files += analysis.simd_files;
                            *wgpu_files += analysis.wgpu_files;
                            defects.extend(analysis.defects);
                            barrier_safety.total_barriers += analysis.barrier_safety.total_barriers;
                            barrier_safety.safe_barriers += analysis.barrier_safety.safe_barriers;
                            barrier_safety.unsafe_barriers.extend(analysis.barrier_safety.unsafe_barriers);
                            coalescing.total_operations += analysis.coalescing.total_operations;
                            coalescing.coalesced_operations += analysis.coalescing.coalesced_operations;
                            coalescing.problematic_accesses.extend(analysis.coalescing.problematic_accesses);
                        }
                    }
                }
            }
        }

        if barrier_safety.total_barriers > 0 {
            barrier_safety.safety_score =
                barrier_safety.safe_barriers as f64 / barrier_safety.total_barriers as f64;
        }
        if coalescing.total_operations > 0 {
            coalescing.efficiency =
                coalescing.coalesced_operations as f64 / coalescing.total_operations as f64;
        }

        Ok(())
    }

    fn analyze_file(&self, path: &Path) -> anyhow::Result<FileAnalysis> {
        let content = std::fs::read_to_string(path)?;
        let ext = path
            .extension()
            .map(|e| e.to_string_lossy().to_lowercase())
            .unwrap_or_default();

        let mut analysis = FileAnalysis::default();

        match ext.as_str() {
            "cu" | "cuh" | "ptx" => {
                analysis.cuda_files = 1;
                self.analyze_cuda_content(&content, path, &mut analysis);
            }
            "wgsl" => {
                analysis.wgpu_files = 1;
                self.analyze_wgpu_content(&content, path, &mut analysis);
            }
            "rs" => {
                if content.contains("std::arch::") || content.contains("core::arch::") {
                    analysis.simd_files = 1;
                    self.analyze_simd_content(&content, path, &mut analysis);
                }
                if content.contains("wgpu::")
                    || content.contains("@compute")
                    || content.contains("@workgroup_size")
                {
                    analysis.wgpu_files = 1;
                    self.analyze_wgpu_content(&content, path, &mut analysis);
                }
            }
            "c" | "cpp" | "h" | "hpp" => {
                // Use concat! to avoid self-matching during CB-021 compliance scanning
                if content.contains("immintrin.h")
                    || content.contains(concat!("_mm", "256_"))
                    || content.contains(concat!("_mm", "512_"))
                    || content.contains("arm_neon.h")
                {
                    analysis.simd_files = 1;
                    self.analyze_simd_content(&content, path, &mut analysis);
                }
            }
            _ => {}
        }

        Ok(analysis)
    }
}