pmat 3.16.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
129
130
131
132
133
134
135
136
137
138

#![allow(unused)]
#![cfg_attr(coverage_nightly, coverage(off))]
//! Sprint 31 Week 2 - Performance Profiling Tools
//!
//! Advanced profiling capabilities for the TDG system including flame graphs,
//! call traces, memory profiling, and bottleneck detection.
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;
use tokio::sync::RwLock;

/// Performance profile for a single operation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OperationProfile {
    pub operation_id: String,
    pub operation_type: String,
    #[serde(skip, default = "Instant::now")]
    pub start_time: Instant,
    #[serde(skip)]
    pub end_time: Option<Instant>,
    pub duration_ms: Option<f64>,
    pub memory_before_mb: f64,
    pub memory_after_mb: Option<f64>,
    pub cpu_time_ms: f64,
    pub io_wait_ms: f64,
    pub children: Vec<OperationProfile>,
    pub metadata: HashMap<String, String>,
}

/// Flame graph data structure for visualization
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FlameGraphNode {
    pub name: String,
    pub value: f64, // Duration in milliseconds
    pub children: Vec<FlameGraphNode>,
    pub metadata: HashMap<String, String>,
}

/// Call stack frame for tracing
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CallFrame {
    pub function_name: String,
    pub file_path: String,
    pub line_number: u32,
    pub duration_ms: f64,
    pub self_time_ms: f64,
    pub call_count: u32,
}

/// Memory allocation sample
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemorySample {
    #[serde(skip, default = "Instant::now")]
    pub timestamp: Instant,
    pub heap_used_mb: f64,
    pub heap_total_mb: f64,
    pub stack_used_mb: f64,
    pub gc_count: u32,
    pub gc_pause_ms: f64,
}

/// Bottleneck detection result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Bottleneck {
    pub location: String,
    pub bottleneck_type: BottleneckType,
    pub severity: BottleneckSeverity,
    pub impact_ms: f64,
    pub occurrence_count: u32,
    pub recommendation: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
/// Type classification for bottleneck.
pub enum BottleneckType {
    CpuBound,
    IoBound,
    MemoryBound,
    LockContention,
    NetworkLatency,
    DatabaseQuery,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
/// Severity level classification for bottleneck.
pub enum BottleneckSeverity {
    Low,
    Medium,
    High,
    Critical,
}

/// Advanced performance profiler for the TDG system
pub struct PerformanceProfiler {
    /// Active operation profiles
    active_profiles: Arc<RwLock<HashMap<String, OperationProfile>>>,
    /// Completed profiles
    completed_profiles: Arc<RwLock<Vec<OperationProfile>>>,
    /// Call stack traces
    call_stacks: Arc<RwLock<Vec<Vec<CallFrame>>>>,
    /// Memory samples
    memory_samples: Arc<RwLock<Vec<MemorySample>>>,
    /// Detected bottlenecks
    bottlenecks: Arc<RwLock<Vec<Bottleneck>>>,
    /// Profiling configuration
    config: ProfilerConfig,
}

#[derive(Debug, Clone)]
/// Configuration for profiler.
pub struct ProfilerConfig {
    pub enable_cpu_profiling: bool,
    pub enable_memory_profiling: bool,
    pub enable_io_profiling: bool,
    pub sample_interval_ms: u64,
    pub max_stack_depth: usize,
    pub max_profiles_retained: usize,
}

impl Default for ProfilerConfig {
    fn default() -> Self {
        Self {
            enable_cpu_profiling: true,
            enable_memory_profiling: true,
            enable_io_profiling: true,
            sample_interval_ms: 100,
            max_stack_depth: 50,
            max_profiles_retained: 1000,
        }
    }
}

// --- Included submodules ---

include!("profiler_operations.rs");
include!("profiler_tests.rs");