torsh_jit/advisor/
config.rs

1//! Configuration and core types for the optimization advisor
2
3use crate::{profiler::ProfilingSession, ComputationGraph, NodeId};
4use std::collections::HashMap;
5use std::time::{Duration, SystemTime};
6
7/// Configuration for the optimization advisor
8#[derive(Debug, Clone)]
9pub struct AdvisorConfig {
10    pub version: String,
11    pub max_recommendations: usize,
12    pub min_confidence_threshold: f64,
13    pub min_benefit_threshold: f64,
14    pub enable_learning: bool,
15    pub analysis_depth: AnalysisDepth,
16    pub optimization_goals: OptimizationGoals,
17}
18
19impl Default for AdvisorConfig {
20    fn default() -> Self {
21        Self {
22            version: "1.0.0".to_string(),
23            max_recommendations: 10,
24            min_confidence_threshold: 0.5,
25            min_benefit_threshold: 0.1,
26            enable_learning: true,
27            analysis_depth: AnalysisDepth::Standard,
28            optimization_goals: OptimizationGoals::default(),
29        }
30    }
31}
32
33#[derive(Debug, Clone, PartialEq)]
34pub enum AnalysisDepth {
35    Quick,
36    Standard,
37    Comprehensive,
38}
39
40#[derive(Debug, Clone)]
41pub struct OptimizationGoals {
42    pub prioritize_speed: bool,
43    pub prioritize_memory: bool,
44    pub prioritize_energy: bool,
45    pub enable_aggressive_optimizations: bool,
46}
47
48impl Default for OptimizationGoals {
49    fn default() -> Self {
50        Self {
51            prioritize_speed: true,
52            prioritize_memory: true,
53            prioritize_energy: false,
54            enable_aggressive_optimizations: false,
55        }
56    }
57}
58
59/// Input for optimization analysis
60#[derive(Debug, Clone)]
61pub struct AnalysisInput {
62    pub computation_graph: Option<ComputationGraph>,
63    pub benchmark_results: Option<BenchmarkResults>,
64    pub profiling_data: Option<ProfilingSession>,
65    pub system_constraints: SystemConstraints,
66    pub user_preferences: UserPreferences,
67    pub previous_optimizations: Vec<OptimizationRecommendation>,
68    pub abstract_analysis: Option<crate::abstract_interpretation::AbstractAnalysisResult>,
69    pub symbolic_execution: Option<crate::symbolic_execution::SymbolicExecutionResult>,
70}
71
72#[derive(Debug, Clone)]
73pub struct SystemConstraints {
74    pub memory_gb: usize,
75    pub cpu_cores: usize,
76    pub has_gpu: bool,
77    pub target_platform: TargetPlatform,
78}
79
80impl Default for SystemConstraints {
81    fn default() -> Self {
82        Self {
83            memory_gb: 8,
84            cpu_cores: 4,
85            has_gpu: false,
86            target_platform: TargetPlatform::Desktop,
87        }
88    }
89}
90
91#[derive(Debug, Clone, PartialEq)]
92pub enum TargetPlatform {
93    Desktop,
94    Server,
95    Mobile,
96    Embedded,
97}
98
99#[derive(Debug, Clone)]
100pub struct UserPreferences {
101    pub optimization_aggressiveness: f64,
102    pub risk_tolerance: f64,
103    pub time_constraints: TimeConstraints,
104}
105
106impl Default for UserPreferences {
107    fn default() -> Self {
108        Self {
109            optimization_aggressiveness: 0.5,
110            risk_tolerance: 0.5,
111            time_constraints: TimeConstraints::Unlimited,
112        }
113    }
114}
115
116/// Complete optimization report
117#[derive(Debug)]
118pub struct OptimizationReport {
119    pub recommendations: Vec<OptimizationRecommendation>,
120    pub pattern_analysis: PatternAnalysis,
121    pub performance_analysis: PerformanceAnalysis,
122    pub cost_analysis: CostBenefitAnalysis,
123    pub explanations: Vec<OptimizationExplanation>,
124    pub confidence_scores: ConfidenceScores,
125    pub implementation_complexity: ImplementationComplexity,
126    pub expected_improvements: ExpectedImprovements,
127    pub analysis_metadata: AnalysisMetadata,
128}
129
130/// Individual optimization recommendation
131#[derive(Debug, Clone)]
132pub struct OptimizationRecommendation {
133    pub id: String,
134    pub optimization_type: OptimizationType,
135    pub title: String,
136    pub description: String,
137    pub expected_speedup: f64,
138    pub expected_memory_reduction: f64,
139    pub implementation_complexity: f64,
140    pub confidence: f64,
141    pub risk_level: f64,
142    pub priority_score: f64,
143    pub affected_components: Vec<String>,
144    pub prerequisites: Vec<String>,
145    pub estimated_implementation_time: Duration,
146}
147
148/// Types of optimizations
149#[derive(Debug, Clone, PartialEq, Eq, Hash)]
150pub enum OptimizationType {
151    FusionOptimization,
152    MemoryOptimization,
153    ParallelizationOptimization,
154    VectorizationOptimization,
155    ConstantFoldingOptimization,
156    DeadCodeEliminationOptimization,
157    ComputationOptimization,
158    IOOptimization,
159    CompilationOptimization,
160    ArchitectureOptimization,
161}
162
163impl OptimizationType {
164    pub fn description(&self) -> &'static str {
165        match self {
166            OptimizationType::FusionOptimization => "Fusion",
167            OptimizationType::MemoryOptimization => "Memory",
168            OptimizationType::ParallelizationOptimization => "Parallelization",
169            OptimizationType::VectorizationOptimization => "Vectorization",
170            OptimizationType::ConstantFoldingOptimization => "Constant Folding",
171            OptimizationType::DeadCodeEliminationOptimization => "Dead Code Elimination",
172            OptimizationType::ComputationOptimization => "Computation",
173            OptimizationType::IOOptimization => "I/O",
174            OptimizationType::CompilationOptimization => "Compilation",
175            OptimizationType::ArchitectureOptimization => "Architecture",
176        }
177    }
178}
179
180/// Pattern analysis results
181#[derive(Debug)]
182pub struct PatternAnalysis {
183    pub detected_patterns: Vec<DetectedPattern>,
184    pub antipatterns: Vec<DetectedAntipattern>,
185    pub optimization_opportunities: Vec<OptimizationOpportunity>,
186    pub pattern_frequency: HashMap<String, f64>,
187    pub complexity_metrics: ComplexityMetrics,
188}
189
190/// Detected optimization pattern
191#[derive(Debug)]
192pub struct DetectedPattern {
193    pub pattern_type: PatternType,
194    pub location: PatternLocation,
195    pub confidence: f64,
196    pub description: String,
197    pub estimated_benefit: f64,
198}
199
200#[derive(Debug, Clone)]
201pub enum PatternType {
202    FusionOpportunity,
203    MemoryInefficiency,
204    ParallelizationOpportunity,
205    VectorizationOpportunity,
206    ComputationPattern,
207}
208
209/// Detected antipattern
210#[derive(Debug)]
211pub struct DetectedAntipattern {
212    pub antipattern_type: AntipatternType,
213    pub location: PatternLocation,
214    pub severity: f64,
215    pub description: String,
216    pub fix_suggestion: String,
217}
218
219#[derive(Debug, Clone)]
220pub enum AntipatternType {
221    RedundantComputation,
222    PoorMemoryLocality,
223    InefficientAlgorithm,
224    ExcessiveAllocation,
225}
226
227impl AntipatternType {
228    pub fn description(&self) -> &'static str {
229        match self {
230            AntipatternType::RedundantComputation => "Redundant Computation",
231            AntipatternType::PoorMemoryLocality => "Poor Memory Locality",
232            AntipatternType::InefficientAlgorithm => "Inefficient Algorithm",
233            AntipatternType::ExcessiveAllocation => "Excessive Allocation",
234        }
235    }
236}
237
238/// Location of a pattern in the graph
239#[derive(Debug)]
240pub enum PatternLocation {
241    Node(NodeId),
242    Nodes(Vec<NodeId>),
243    Subgraph(Vec<Vec<NodeId>>),
244    Global,
245}
246
247/// Optimization opportunity
248#[derive(Debug)]
249pub struct OptimizationOpportunity {
250    pub opportunity_type: OpportunityType,
251    pub location: PatternLocation,
252    pub estimated_benefit: f64,
253    pub implementation_complexity: f64,
254    pub prerequisites: Vec<String>,
255    pub description: String,
256}
257
258impl OptimizationOpportunity {
259    pub fn can_be_combined_with(&self, other: &Self) -> bool {
260        use OptimizationType::*;
261
262        matches!(
263            (
264                self.opportunity_type.to_optimization_type(),
265                other.opportunity_type.to_optimization_type()
266            ),
267            (FusionOptimization, VectorizationOptimization)
268                | (MemoryOptimization, ComputationOptimization)
269                | (ConstantFoldingOptimization, FusionOptimization)
270        )
271    }
272}
273
274#[derive(Debug)]
275pub enum OpportunityType {
276    FusionOptimization,
277    MemoryOptimization,
278    ParallelizationOptimization,
279    VectorizationOptimization,
280    ConstantFolding,
281    DeadCodeElimination,
282    ComputationOptimization,
283}
284
285impl OpportunityType {
286    pub fn to_optimization_type(&self) -> OptimizationType {
287        match self {
288            OpportunityType::FusionOptimization => OptimizationType::FusionOptimization,
289            OpportunityType::MemoryOptimization => OptimizationType::MemoryOptimization,
290            OpportunityType::ParallelizationOptimization => {
291                OptimizationType::ParallelizationOptimization
292            }
293            OpportunityType::VectorizationOptimization => {
294                OptimizationType::VectorizationOptimization
295            }
296            OpportunityType::ConstantFolding => OptimizationType::ConstantFoldingOptimization,
297            OpportunityType::DeadCodeElimination => {
298                OptimizationType::DeadCodeEliminationOptimization
299            }
300            OpportunityType::ComputationOptimization => OptimizationType::ComputationOptimization,
301        }
302    }
303}
304
305/// Performance analysis results
306#[derive(Debug, Clone)]
307pub struct PerformanceAnalysis {
308    pub bottlenecks: Vec<PerformanceBottleneck>,
309    pub hotspots: Vec<PerformanceHotspot>,
310    pub execution_profile: ExecutionProfile,
311    pub resource_utilization: ResourceUtilization,
312    pub scalability_analysis: ScalabilityAnalysis,
313}
314
315/// Performance bottleneck
316#[derive(Debug, Clone)]
317pub struct PerformanceBottleneck {
318    pub bottleneck_type: BottleneckType,
319    pub location: String,
320    pub severity: f64,
321    pub description: String,
322    pub suggested_fixes: Vec<String>,
323}
324
325#[derive(Debug, Clone)]
326pub enum BottleneckType {
327    Memory,
328    Computation,
329    IO,
330    Synchronization,
331}
332
333impl BottleneckType {
334    pub fn description(&self) -> &'static str {
335        match self {
336            BottleneckType::Memory => "Memory",
337            BottleneckType::Computation => "Computation",
338            BottleneckType::IO => "I/O",
339            BottleneckType::Synchronization => "Synchronization",
340        }
341    }
342}
343
344/// Performance hotspot
345#[derive(Debug, Clone)]
346pub struct PerformanceHotspot {
347    pub location: String,
348    pub execution_time_percent: f64,
349    pub memory_usage_percent: f64,
350    pub frequency: usize,
351    pub optimization_potential: f64,
352}
353
354/// Cost-benefit analysis
355#[derive(Debug)]
356pub struct CostBenefitAnalysis {
357    pub implementation_costs: HashMap<String, f64>,
358    pub expected_benefits: HashMap<String, f64>,
359    pub risk_assessments: HashMap<String, f64>,
360    pub roi_estimates: HashMap<String, f64>,
361    pub priority_rankings: Vec<(String, f64)>,
362}
363
364/// Optimization explanation
365#[derive(Debug, Clone)]
366pub struct OptimizationExplanation {
367    pub recommendation_id: String,
368    pub why_beneficial: String,
369    pub how_to_implement: String,
370    pub potential_risks: Vec<String>,
371    pub verification_steps: Vec<String>,
372    pub expected_timeline: Duration,
373}
374
375/// Analysis metadata
376#[derive(Debug)]
377pub struct AnalysisMetadata {
378    pub analysis_time: Duration,
379    pub advisor_version: String,
380    pub input_characteristics: String,
381    pub recommendations_count: usize,
382    pub timestamp: SystemTime,
383}
384
385/// Confidence scores for different aspects of analysis
386#[derive(Debug)]
387pub struct ConfidenceScores {
388    pub overall_confidence: f64,
389    pub pattern_detection_confidence: f64,
390    pub performance_analysis_confidence: f64,
391    pub cost_estimation_confidence: f64,
392    pub implementation_assessment_confidence: f64,
393}
394
395/// Implementation complexity assessment
396#[derive(Debug)]
397pub struct ImplementationComplexity {
398    pub overall_complexity: f64,
399    pub technical_complexity: f64,
400    pub coordination_complexity: f64,
401    pub testing_complexity: f64,
402    pub deployment_complexity: f64,
403}
404
405/// Expected improvements from optimizations
406#[derive(Debug)]
407pub struct ExpectedImprovements {
408    pub performance_improvement: f64,
409    pub memory_reduction: f64,
410    pub energy_savings: f64,
411    pub development_time_impact: Duration,
412    pub maintenance_impact: f64,
413}
414
415/// Execution profile information
416#[derive(Debug, Clone)]
417pub struct ExecutionProfile {
418    pub total_execution_time: Duration,
419    pub memory_peak_usage: usize,
420    pub cpu_utilization: f64,
421    pub io_operations: usize,
422    pub cache_miss_rate: f64,
423}
424
425/// Resource utilization metrics
426#[derive(Debug, Clone)]
427pub struct ResourceUtilization {
428    pub cpu_usage: f64,
429    pub memory_usage: f64,
430    pub io_bandwidth_usage: f64,
431    pub network_usage: f64,
432    pub gpu_usage: Option<f64>,
433}
434
435/// Scalability analysis results
436#[derive(Debug, Clone)]
437pub struct ScalabilityAnalysis {
438    pub parallelization_potential: f64,
439    pub memory_scalability: f64,
440    pub io_scalability: f64,
441    pub algorithmic_complexity: String,
442    pub bottleneck_scalability: HashMap<String, f64>,
443}
444
445/// Complexity metrics
446#[derive(Debug)]
447pub struct ComplexityMetrics {
448    pub cyclomatic_complexity: usize,
449    pub data_flow_complexity: usize,
450    pub control_flow_complexity: usize,
451    pub computational_complexity: String,
452    pub memory_complexity: String,
453}
454
455/// Loop information for analysis
456#[derive(Debug)]
457pub struct LoopInfo {
458    pub nodes: Vec<NodeId>,
459    pub iteration_bound: Option<usize>,
460    pub optimization_potential: f64,
461}
462
463/// Known optimization pattern in knowledge base
464#[derive(Debug)]
465pub struct KnownPattern {
466    pub name: String,
467    pub description: String,
468    pub detection_criteria: String,
469    pub optimization_potential: f64,
470}
471
472/// Known optimization technique
473#[derive(Debug)]
474pub struct KnownOptimization {
475    pub name: String,
476    pub description: String,
477    pub applicability_conditions: Vec<String>,
478    pub expected_benefit: f64,
479    pub implementation_complexity: f64,
480}
481
482/// Optimization heuristic
483#[derive(Debug)]
484pub struct OptimizationHeuristic {
485    pub name: String,
486    pub condition: String,
487    pub recommendation: String,
488    pub confidence: f64,
489}
490
491/// Analysis record for learning system
492#[derive(Debug)]
493pub struct AnalysisRecord {
494    pub timestamp: SystemTime,
495    pub input_characteristics: String,
496    pub recommendations_count: usize,
497    pub avg_confidence: f64,
498}
499
500/// Time constraints for optimization work
501#[derive(Debug, Clone, PartialEq)]
502pub enum TimeConstraints {
503    Unlimited,
504    Hours(u32),
505    Days(u32),
506    Weeks(u32),
507}
508
509/// Overall analysis summary
510#[derive(Debug, Clone)]
511pub struct OverallAnalysis {
512    pub total_opportunities: usize,
513    pub estimated_speedup: f64,
514    pub estimated_memory_reduction: f64,
515    pub implementation_complexity: f64,
516    pub confidence: f64,
517    pub risk_assessment: RiskAssessment,
518    pub priority_distribution: PriorityDistribution,
519}
520
521/// Detailed explanation for recommendations
522#[derive(Debug, Clone)]
523pub struct DetailedExplanation {
524    pub recommendation_id: String,
525    pub rationale: String,
526    pub implementation_steps: Vec<String>,
527    pub potential_issues: Vec<String>,
528    pub success_indicators: Vec<String>,
529}
530
531/// Confidence analysis for the overall report
532#[derive(Debug, Clone)]
533pub struct ConfidenceAnalysis {
534    pub overall_confidence: f64,
535    pub data_quality_score: f64,
536    pub analysis_completeness: f64,
537    pub recommendation_reliability: f64,
538}
539
540/// Risk assessment for recommendations
541#[derive(Debug, Clone)]
542pub struct RiskAssessment {
543    pub overall_risk_level: f64,
544    pub high_risk_recommendations: usize,
545    pub risk_factors: Vec<String>,
546    pub mitigation_strategies: Vec<String>,
547}
548
549/// Distribution of recommendation priorities
550#[derive(Debug, Clone)]
551pub struct PriorityDistribution {
552    pub high_priority: usize,
553    pub medium_priority: usize,
554    pub low_priority: usize,
555}
556
557impl Default for RiskAssessment {
558    fn default() -> Self {
559        Self {
560            overall_risk_level: 0.5,
561            high_risk_recommendations: 0,
562            risk_factors: Vec::new(),
563            mitigation_strategies: Vec::new(),
564        }
565    }
566}
567
568/// Placeholder for benchmark results (to avoid external dependency)
569#[derive(Debug, Clone)]
570pub struct BenchmarkResults {
571    pub total_execution_time: Duration,
572    pub operation_timings: HashMap<String, OperationTiming>,
573    pub memory_statistics: Option<MemoryStatistics>,
574    pub resource_usage: Option<ResourceStats>,
575}
576
577/// Operation timing information
578#[derive(Debug, Clone)]
579pub struct OperationTiming {
580    pub average_duration: Duration,
581    pub sample_count: usize,
582}
583
584/// Memory usage statistics
585#[derive(Debug, Clone)]
586pub struct MemoryStatistics {
587    pub peak_usage: usize,
588    pub allocated: usize,
589}
590
591/// Resource usage statistics
592#[derive(Debug, Clone)]
593pub struct ResourceStats {
594    pub cpu_utilization: f64,
595    pub memory_utilization: f64,
596    pub io_utilization: f64,
597}
torsh_jit/advisor/config.rs

torsh_jit/advisor/
config.rs
