1#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
161pub enum MemoryAccessPattern {
162 Sequential,
163 Random,
164 Strided,
165 Mixed,
166}
167
168#[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#[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#[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#[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#[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#[derive(Debug, Clone, PartialEq, PartialOrd, serde::Serialize, serde::Deserialize)]
225pub enum CorrelationStrength {
226 VeryWeak, Weak, Moderate, Strong, VeryStrong, }
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#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
247pub enum CorrelationType {
248 Causal, Complementary, Competitive, Sequential, Independent, }
254
255#[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#[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#[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#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
292pub enum PerformancePatternType {
293 RegularCycle, BurstActivity, GradualDegradation, SpikesAndDips, ConstantLoad, Oscillation, }
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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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}