Skip to main content

torsh_profiler/core/
metrics.rs

1//! Core profiling metrics and analysis types
2
3/// Overhead statistics for profiling operations
4#[derive(Debug, Clone, Default)]
5pub struct OverheadStats {
6    pub add_event_time_ns: u64,
7    pub add_event_count: u64,
8    pub stack_trace_time_ns: u64,
9    pub stack_trace_count: u64,
10    pub export_time_ns: u64,
11    pub export_count: u64,
12    pub total_overhead_ns: u64,
13}
14
15/// Bottleneck detection results
16#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
17pub struct BottleneckAnalysis {
18    pub slowest_operations: Vec<BottleneckEvent>,
19    pub memory_hotspots: Vec<MemoryHotspot>,
20    pub thread_contention: Vec<ThreadContentionEvent>,
21    pub efficiency_issues: Vec<EfficiencyIssue>,
22    pub recommendations: Vec<String>,
23}
24
25/// A performance bottleneck event
26#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
27pub struct BottleneckEvent {
28    pub name: String,
29    pub category: String,
30    pub duration_us: u64,
31    pub thread_id: usize,
32    pub severity: BottleneckSeverity,
33    pub impact_score: f64,
34    pub recommendation: String,
35}
36
37/// Memory hotspot information
38#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
39pub struct MemoryHotspot {
40    pub location: String,
41    pub total_allocations: usize,
42    pub total_bytes: usize,
43    pub average_size: f64,
44    pub peak_concurrent_allocations: usize,
45    pub severity: BottleneckSeverity,
46}
47
48/// Thread contention event
49#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
50pub struct ThreadContentionEvent {
51    pub thread_id: usize,
52    pub operation: String,
53    pub wait_time_us: u64,
54    pub contention_count: usize,
55}
56
57/// Efficiency issue
58#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
59pub struct EfficiencyIssue {
60    pub issue_type: EfficiencyIssueType,
61    pub description: String,
62    pub affected_operations: Vec<String>,
63    pub performance_impact: f64,
64    pub recommendation: String,
65}
66
67/// Type of efficiency issue
68#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
69pub enum EfficiencyIssueType {
70    LowThroughput,
71    HighLatency,
72    MemoryWaste,
73    CpuUnderutilization,
74    FrequentAllocation,
75    LargeAllocation,
76}
77
78/// Severity of a bottleneck
79#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
80pub enum BottleneckSeverity {
81    Low,
82    Medium,
83    High,
84    Critical,
85}
86
87/// Efficiency metrics analysis
88#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
89pub struct EfficiencyMetrics {
90    pub cpu_efficiency: CpuEfficiency,
91    pub memory_efficiency: MemoryEfficiency,
92    pub cache_efficiency: CacheEfficiency,
93    pub throughput_metrics: ThroughputMetrics,
94    pub resource_utilization: ResourceUtilization,
95    pub overall_score: f64,
96    pub recommendations: Vec<String>,
97}
98
99/// CPU efficiency metrics
100#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
101pub struct CpuEfficiency {
102    pub utilization_percentage: f64,
103    pub instructions_per_cycle: f64,
104    pub computational_intensity: f64,
105    pub parallelism_efficiency: f64,
106    pub idle_time_percentage: f64,
107}
108
109/// Memory efficiency metrics
110#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
111pub struct MemoryEfficiency {
112    pub bandwidth_utilization: f64,
113    pub cache_hit_ratio: f64,
114    pub memory_access_pattern: MemoryAccessPattern,
115    pub allocation_efficiency: f64,
116    pub fragmentation_ratio: f64,
117}
118
119/// Cache efficiency metrics
120#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
121pub struct CacheEfficiency {
122    pub l1_hit_rate: f64,
123    pub l2_hit_rate: f64,
124    pub l3_hit_rate: f64,
125    pub memory_locality_score: f64,
126    pub cache_miss_penalty: f64,
127}
128
129/// Throughput metrics
130#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
131pub struct ThroughputMetrics {
132    pub operations_per_second: f64,
133    pub flops_per_second: f64,
134    pub bandwidth_gb_per_second: f64,
135    pub latency_percentiles: LatencyPercentiles,
136    pub throughput_efficiency: f64,
137}
138
139/// Resource utilization metrics
140#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
141pub struct ResourceUtilization {
142    pub cpu_cores_used: usize,
143    pub memory_usage_mb: f64,
144    pub peak_memory_mb: f64,
145    pub thread_efficiency: f64,
146    pub load_balance_score: f64,
147}
148
149/// Latency percentiles
150#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
151pub struct LatencyPercentiles {
152    pub p50: f64,
153    pub p90: f64,
154    pub p95: f64,
155    pub p99: f64,
156    pub max: f64,
157}
158
159/// Memory access pattern
160#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
161pub enum MemoryAccessPattern {
162    Sequential,
163    Random,
164    Strided,
165    Mixed,
166}
167
168/// Correlation analysis results
169#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
170pub struct CorrelationAnalysis {
171    pub operation_correlations: Vec<OperationCorrelation>,
172    pub performance_correlations: Vec<PerformanceCorrelation>,
173    pub memory_correlations: Vec<MemoryCorrelation>,
174    pub temporal_correlations: Vec<TemporalCorrelation>,
175    pub correlation_summary: CorrelationSummary,
176}
177
178/// Correlation between two operations
179#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
180pub struct OperationCorrelation {
181    pub operation_a: String,
182    pub operation_b: String,
183    pub correlation_coefficient: f64,
184    pub co_occurrence_frequency: f64,
185    pub temporal_proximity: f64,
186    pub correlation_strength: CorrelationStrength,
187    pub correlation_type: CorrelationType,
188    pub insights: Vec<String>,
189}
190
191/// Performance metric correlation
192#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
193pub struct PerformanceCorrelation {
194    pub metric_a: String,
195    pub metric_b: String,
196    pub correlation_coefficient: f64,
197    pub significance_level: f64,
198    pub sample_size: usize,
199    pub correlation_strength: CorrelationStrength,
200}
201
202/// Memory usage correlation
203#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
204pub struct MemoryCorrelation {
205    pub operation: String,
206    pub memory_metric: String,
207    pub duration_correlation: f64,
208    pub bytes_correlation: f64,
209    pub allocation_pattern: String,
210    pub correlation_strength: CorrelationStrength,
211}
212
213/// Temporal relationship between operations
214#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
215pub struct TemporalCorrelation {
216    pub operation_sequence: Vec<String>,
217    pub sequence_frequency: f64,
218    pub average_interval: f64,
219    pub sequence_efficiency: f64,
220    pub optimization_potential: f64,
221}
222
223/// Correlation strength classification
224#[derive(Debug, Clone, PartialEq, PartialOrd, serde::Serialize, serde::Deserialize)]
225pub enum CorrelationStrength {
226    VeryWeak,   // |r| < 0.2
227    Weak,       // 0.2 <= |r| < 0.4
228    Moderate,   // 0.4 <= |r| < 0.6
229    Strong,     // 0.6 <= |r| < 0.8
230    VeryStrong, // |r| >= 0.8
231}
232
233impl std::fmt::Display for CorrelationStrength {
234    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
235        match self {
236            CorrelationStrength::VeryWeak => write!(f, "Very Weak"),
237            CorrelationStrength::Weak => write!(f, "Weak"),
238            CorrelationStrength::Moderate => write!(f, "Moderate"),
239            CorrelationStrength::Strong => write!(f, "Strong"),
240            CorrelationStrength::VeryStrong => write!(f, "Very Strong"),
241        }
242    }
243}
244
245/// Type of correlation
246#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
247pub enum CorrelationType {
248    Causal,        // One operation directly affects another
249    Complementary, // Operations work together
250    Competitive,   // Operations compete for resources
251    Sequential,    // Operations follow in sequence
252    Independent,   // No significant relationship
253}
254
255/// Summary of correlation analysis
256#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
257pub struct CorrelationSummary {
258    pub total_correlations_analyzed: usize,
259    pub strong_correlations_found: usize,
260    pub causal_relationships: usize,
261    pub bottleneck_correlations: usize,
262    pub optimization_opportunities: Vec<String>,
263    pub key_insights: Vec<String>,
264}
265
266/// Pattern detection analysis results
267#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
268pub struct PatternAnalysis {
269    pub performance_patterns: Vec<PerformancePattern>,
270    pub bottleneck_patterns: Vec<BottleneckPattern>,
271    pub resource_patterns: Vec<ResourcePattern>,
272    pub temporal_patterns: Vec<TemporalPattern>,
273    pub optimization_patterns: Vec<OptimizationPattern>,
274    pub pattern_summary: PatternSummary,
275}
276
277/// Recurring performance pattern
278#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
279pub struct PerformancePattern {
280    pub pattern_type: PerformancePatternType,
281    pub operations: Vec<String>,
282    pub frequency: f64,
283    pub average_duration: f64,
284    pub variance: f64,
285    pub confidence_score: f64,
286    pub impact_level: PatternImpact,
287    pub description: String,
288}
289
290/// Type of performance pattern
291#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
292pub enum PerformancePatternType {
293    RegularCycle,       // Recurring operations with regular intervals
294    BurstActivity,      // Periods of high activity followed by low activity
295    GradualDegradation, // Performance gradually getting worse
296    SpikesAndDips,      // Irregular spikes and dips in performance
297    ConstantLoad,       // Steady, consistent performance
298    Oscillation,        // Performance oscillates between states
299}
300
301impl std::fmt::Display for PerformancePatternType {
302    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
303        match self {
304            PerformancePatternType::RegularCycle => write!(f, "Regular Cycle"),
305            PerformancePatternType::BurstActivity => write!(f, "Burst Activity"),
306            PerformancePatternType::GradualDegradation => write!(f, "Gradual Degradation"),
307            PerformancePatternType::SpikesAndDips => write!(f, "Spikes and Dips"),
308            PerformancePatternType::ConstantLoad => write!(f, "Constant Load"),
309            PerformancePatternType::Oscillation => write!(f, "Oscillation"),
310        }
311    }
312}
313
314/// Bottleneck pattern
315#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
316pub struct BottleneckPattern {
317    pub pattern_id: String,
318    pub bottleneck_operations: Vec<String>,
319    pub occurrence_frequency: f64,
320    pub average_severity: f64,
321    pub blocking_relationships: Vec<BlockingRelationship>,
322    pub root_cause_analysis: RootCauseAnalysis,
323    pub mitigation_strategies: Vec<String>,
324}
325
326/// Resource usage pattern
327#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
328pub struct ResourcePattern {
329    pub resource_type: ResourceType,
330    pub usage_pattern: UsagePatternType,
331    pub peak_usage_times: Vec<u64>,
332    pub utilization_efficiency: f64,
333    pub waste_indicators: Vec<WasteIndicator>,
334    pub optimization_potential: f64,
335}
336
337/// Temporal execution pattern
338#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
339pub struct TemporalPattern {
340    pub pattern_name: String,
341    pub operation_sequence: Vec<String>,
342    pub sequence_probability: f64,
343    pub execution_consistency: f64,
344    pub timing_variance: f64,
345    pub parallelization_opportunities: Vec<ParallelizationOpportunity>,
346}
347
348/// Optimization opportunity pattern
349#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
350pub struct OptimizationPattern {
351    pub optimization_type: OptimizationType,
352    pub affected_operations: Vec<String>,
353    pub potential_improvement: f64,
354    pub implementation_complexity: ComplexityLevel,
355    pub confidence_level: f64,
356    pub prerequisites: Vec<String>,
357    pub estimated_effort: EffortLevel,
358}
359
360/// Type of resource
361#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
362pub enum ResourceType {
363    Cpu,
364    Memory,
365    Bandwidth,
366    Storage,
367    Network,
368    Compute,
369}
370
371/// Usage pattern type
372#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
373pub enum UsagePatternType {
374    Steady,
375    Bursty,
376    Cyclical,
377    Growing,
378    Declining,
379    Random,
380}
381
382/// Waste indicator
383#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
384pub struct WasteIndicator {
385    pub indicator_type: WasteType,
386    pub severity: f64,
387    pub description: String,
388    pub recommendations: Vec<String>,
389}
390
391/// Type of waste
392#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
393pub enum WasteType {
394    IdleTime,
395    MemoryLeaks,
396    RedundantOperations,
397    InefficientAlgorithm,
398    PoorCacheUsage,
399    ExcessiveAllocation,
400}
401
402/// Blocking relationship between operations
403#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
404pub struct BlockingRelationship {
405    pub blocker: String,
406    pub blocked: String,
407    pub blocking_duration: f64,
408    pub frequency: f64,
409    pub impact_score: f64,
410}
411
412/// Root cause analysis
413#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
414pub struct RootCauseAnalysis {
415    pub primary_cause: String,
416    pub contributing_factors: Vec<String>,
417    pub evidence_strength: f64,
418    pub analysis_confidence: f64,
419}
420
421/// Parallelization opportunity
422#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
423pub struct ParallelizationOpportunity {
424    pub operations: Vec<String>,
425    pub parallel_potential: f64,
426    pub data_dependencies: Vec<String>,
427    pub expected_speedup: f64,
428}
429
430/// Type of optimization
431#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
432pub enum OptimizationType {
433    Parallelization,
434    Vectorization,
435    CacheOptimization,
436    MemoryPooling,
437    AlgorithmChange,
438    DataStructureOptimization,
439    ConcurrencyImprovement,
440}
441
442impl std::fmt::Display for OptimizationType {
443    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
444        match self {
445            OptimizationType::Parallelization => write!(f, "Parallelization"),
446            OptimizationType::Vectorization => write!(f, "Vectorization"),
447            OptimizationType::CacheOptimization => write!(f, "Cache Optimization"),
448            OptimizationType::MemoryPooling => write!(f, "Memory Pooling"),
449            OptimizationType::AlgorithmChange => write!(f, "Algorithm Change"),
450            OptimizationType::DataStructureOptimization => write!(f, "Data Structure Optimization"),
451            OptimizationType::ConcurrencyImprovement => write!(f, "Concurrency Improvement"),
452        }
453    }
454}
455
456/// Pattern impact level
457#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
458pub enum PatternImpact {
459    Negligible,
460    Low,
461    Medium,
462    High,
463    Critical,
464}
465
466/// Implementation complexity
467#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
468pub enum ComplexityLevel {
469    Trivial,
470    Low,
471    Medium,
472    High,
473    VeryHigh,
474}
475
476/// Implementation effort level
477#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
478pub enum EffortLevel {
479    Minimal,
480    Low,
481    Medium,
482    High,
483    Significant,
484}
485
486/// Summary of pattern detection
487#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
488pub struct PatternSummary {
489    pub total_patterns_detected: usize,
490    pub critical_patterns: usize,
491    pub optimization_opportunities: usize,
492    pub bottleneck_patterns: usize,
493    pub key_recommendations: Vec<String>,
494    pub pattern_confidence: f64,
495    pub analysis_completeness: f64,
496}