quantrs2_device/adaptive_compilation/
config.rs

1//! Core Configuration Types for Adaptive Compilation
2
3use std::collections::HashMap;
4use std::time::Duration;
5
6use super::hardware_adaptation::*;
7use super::ml_integration::*;
8use super::monitoring::*;
9use super::strategies::*;
10
11/// Configuration for adaptive compilation pipeline
12#[derive(Debug, Clone)]
13pub struct AdaptiveCompilationConfig {
14    /// Real-time optimization settings
15    pub realtime_optimization: RealtimeOptimizationConfig,
16    /// Adaptive strategies configuration
17    pub adaptive_strategies: AdaptiveStrategiesConfig,
18    /// Performance monitoring configuration
19    pub performance_monitoring: PerformanceMonitoringConfig,
20    /// Machine learning configuration
21    pub ml_optimization: MLOptimizationConfig,
22    /// Circuit analysis configuration
23    pub circuit_analysis: CircuitAnalysisConfig,
24    /// Hardware adaptation configuration
25    pub hardware_adaptation: HardwareAdaptationConfig,
26    /// Optimization objectives and weights
27    pub optimization_objectives: OptimizationObjectivesConfig,
28    /// Caching and learning configuration
29    pub caching_learning: CachingLearningConfig,
30}
31
32/// Real-time optimization configuration
33#[derive(Debug, Clone)]
34pub struct RealtimeOptimizationConfig {
35    /// Enable real-time optimization
36    pub enable_realtime: bool,
37    /// Optimization update interval
38    pub update_interval: Duration,
39    /// Performance threshold for triggering re-optimization
40    pub performance_threshold: f64,
41    /// Maximum optimization time per iteration
42    pub max_optimization_time: Duration,
43    /// Optimization algorithms to use
44    pub optimization_algorithms: Vec<OptimizationAlgorithm>,
45    /// Parallel optimization settings
46    pub parallel_optimization: ParallelOptimizationConfig,
47    /// Adaptive algorithm selection
48    pub adaptive_algorithm_selection: bool,
49}
50
51/// Optimization objectives configuration
52#[derive(Debug, Clone)]
53pub struct OptimizationObjectivesConfig {
54    /// Primary objectives and weights
55    pub primary_objectives: HashMap<String, f64>,
56    /// Secondary objectives and weights
57    pub secondary_objectives: HashMap<String, f64>,
58    /// Constraint definitions
59    pub constraints: Vec<OptimizationConstraint>,
60    /// Multi-objective optimization settings
61    pub multi_objective: MultiObjectiveConfig,
62    /// Dynamic objective weighting
63    pub dynamic_weighting: DynamicWeightingConfig,
64}
65
66/// Caching and learning configuration
67#[derive(Debug, Clone)]
68pub struct CachingLearningConfig {
69    /// Enable intelligent caching
70    pub enable_caching: bool,
71    /// Cache size limits
72    pub cache_size_limits: CacheSizeLimits,
73    /// Cache eviction policies
74    pub eviction_policies: EvictionPolicies,
75    /// Learning from cached results
76    pub cache_learning: CacheLearningConfig,
77    /// Distributed caching settings
78    pub distributed_caching: DistributedCachingConfig,
79}
80
81/// Optimization constraint definition
82#[derive(Debug, Clone)]
83pub struct OptimizationConstraint {
84    /// Constraint name
85    pub name: String,
86    /// Constraint type
87    pub constraint_type: ConstraintType,
88    /// Constraint value or bound
89    pub value: f64,
90    /// Priority level
91    pub priority: f64,
92}
93
94/// Types of optimization constraints
95#[derive(Debug, Clone, PartialEq)]
96pub enum ConstraintType {
97    MaxExecutionTime,
98    MinFidelity,
99    MaxResourceUsage,
100    MaxCircuitDepth,
101    MaxGateCount,
102    EnergyBudget,
103    Custom(String),
104}
105
106/// Multi-objective optimization configuration
107#[derive(Debug, Clone)]
108pub struct MultiObjectiveConfig {
109    /// Enable multi-objective optimization
110    pub enable_multi_objective: bool,
111    /// Pareto frontier exploration
112    pub pareto_exploration: ParetoExplorationConfig,
113    /// Objective trade-off strategies
114    pub trade_off_strategies: Vec<TradeOffStrategy>,
115    /// Solution ranking method
116    pub ranking_method: RankingMethod,
117}
118
119/// Pareto frontier exploration configuration
120#[derive(Debug, Clone)]
121pub struct ParetoExplorationConfig {
122    /// Number of solutions to maintain
123    pub solution_count: usize,
124    /// Diversity preservation
125    pub diversity_preservation: bool,
126    /// Convergence criteria
127    pub convergence_criteria: ConvergenceCriteria,
128}
129
130/// Trade-off strategies between objectives
131#[derive(Debug, Clone, PartialEq)]
132pub enum TradeOffStrategy {
133    WeightedSum,
134    EpsilonConstraint,
135    Lexicographic,
136    GoalProgramming,
137    NSGA2,
138    MOEA,
139}
140
141/// Solution ranking methods
142#[derive(Debug, Clone, PartialEq)]
143pub enum RankingMethod {
144    Dominance,
145    TOPSIS,
146    WeightedSum,
147    Utility,
148    Custom(String),
149}
150
151/// Convergence criteria for optimization
152#[derive(Debug, Clone)]
153pub struct ConvergenceCriteria {
154    /// Maximum iterations
155    pub max_iterations: usize,
156    /// Objective improvement threshold
157    pub improvement_threshold: f64,
158    /// Stagnation detection
159    pub stagnation_tolerance: usize,
160    /// Time limit
161    pub time_limit: Duration,
162}
163
164/// Dynamic objective weighting configuration
165#[derive(Debug, Clone)]
166pub struct DynamicWeightingConfig {
167    /// Enable dynamic weighting
168    pub enable_dynamic: bool,
169    /// Weighting adaptation strategy
170    pub adaptation_strategy: WeightingStrategy,
171    /// Update frequency
172    pub update_frequency: Duration,
173    /// Historical influence
174    pub historical_influence: f64,
175}
176
177/// Weighting adaptation strategies
178#[derive(Debug, Clone, PartialEq)]
179pub enum WeightingStrategy {
180    PerformanceBased,
181    AdaptiveBayesian,
182    ReinforcementLearning,
183    GradientBased,
184    Evolutionary,
185}
186
187/// Cache size limits configuration
188#[derive(Debug, Clone)]
189pub struct CacheSizeLimits {
190    /// Circuit cache size (number of circuits)
191    pub circuit_cache_size: usize,
192    /// Optimization result cache size
193    pub optimization_cache_size: usize,
194    /// Performance data cache size
195    pub performance_cache_size: usize,
196    /// Memory limit for caching (in MB)
197    pub memory_limit_mb: usize,
198}
199
200/// Cache eviction policies
201#[derive(Debug, Clone)]
202pub struct EvictionPolicies {
203    /// Policy for circuit cache
204    pub circuit_cache_policy: EvictionPolicy,
205    /// Policy for optimization cache
206    pub optimization_cache_policy: EvictionPolicy,
207    /// Policy for performance cache
208    pub performance_cache_policy: EvictionPolicy,
209}
210
211/// Cache eviction policy types
212#[derive(Debug, Clone, PartialEq)]
213pub enum EvictionPolicy {
214    LRU,
215    LFU,
216    PerformanceBased,
217    AgeBased,
218    SizeBased,
219    Hybrid,
220}
221
222/// Cache learning configuration
223#[derive(Debug, Clone)]
224pub struct CacheLearningConfig {
225    /// Enable learning from cache
226    pub enable_cache_learning: bool,
227    /// Pattern recognition in cached results
228    pub pattern_recognition: bool,
229    /// Predictive pre-caching
230    pub predictive_precaching: bool,
231    /// Cache hit prediction
232    pub cache_hit_prediction: bool,
233}
234
235/// Distributed caching configuration
236#[derive(Debug, Clone)]
237pub struct DistributedCachingConfig {
238    /// Enable distributed caching
239    pub enable_distributed: bool,
240    /// Cache consistency model
241    pub consistency_model: ConsistencyModel,
242    /// Cache replication factor
243    pub replication_factor: usize,
244    /// Cache synchronization strategy
245    pub synchronization_strategy: SynchronizationStrategy,
246}
247
248/// Cache consistency models
249#[derive(Debug, Clone, PartialEq)]
250pub enum ConsistencyModel {
251    StrongConsistency,
252    EventualConsistency,
253    WeakConsistency,
254    SessionConsistency,
255}
256
257/// Cache synchronization strategies
258#[derive(Debug, Clone, PartialEq)]
259pub enum SynchronizationStrategy {
260    Immediate,
261    Batch,
262    LazyPropagation,
263    ConflictFree,
264}
265
266impl Default for AdaptiveCompilationConfig {
267    fn default() -> Self {
268        Self {
269            realtime_optimization: RealtimeOptimizationConfig::default(),
270            adaptive_strategies: AdaptiveStrategiesConfig::default(),
271            performance_monitoring: PerformanceMonitoringConfig::default(),
272            ml_optimization: MLOptimizationConfig::default(),
273            circuit_analysis: CircuitAnalysisConfig::default(),
274            hardware_adaptation: HardwareAdaptationConfig::default(),
275            optimization_objectives: OptimizationObjectivesConfig::default(),
276            caching_learning: CachingLearningConfig::default(),
277        }
278    }
279}
280
281impl Default for RealtimeOptimizationConfig {
282    fn default() -> Self {
283        Self {
284            enable_realtime: true,
285            update_interval: Duration::from_millis(100),
286            performance_threshold: 0.95,
287            max_optimization_time: Duration::from_secs(30),
288            optimization_algorithms: vec![
289                OptimizationAlgorithm::GradientDescent,
290                OptimizationAlgorithm::BayesianOptimization,
291            ],
292            parallel_optimization: ParallelOptimizationConfig::default(),
293            adaptive_algorithm_selection: true,
294        }
295    }
296}
297
298impl Default for OptimizationObjectivesConfig {
299    fn default() -> Self {
300        let mut primary_objectives = HashMap::new();
301        primary_objectives.insert("fidelity".to_string(), 0.6);
302        primary_objectives.insert("execution_time".to_string(), 0.4);
303
304        Self {
305            primary_objectives,
306            secondary_objectives: HashMap::new(),
307            constraints: vec![],
308            multi_objective: MultiObjectiveConfig::default(),
309            dynamic_weighting: DynamicWeightingConfig::default(),
310        }
311    }
312}
313
314impl Default for CachingLearningConfig {
315    fn default() -> Self {
316        Self {
317            enable_caching: true,
318            cache_size_limits: CacheSizeLimits::default(),
319            eviction_policies: EvictionPolicies::default(),
320            cache_learning: CacheLearningConfig::default(),
321            distributed_caching: DistributedCachingConfig::default(),
322        }
323    }
324}
325
326impl Default for MultiObjectiveConfig {
327    fn default() -> Self {
328        Self {
329            enable_multi_objective: true,
330            pareto_exploration: ParetoExplorationConfig::default(),
331            trade_off_strategies: vec![TradeOffStrategy::NSGA2],
332            ranking_method: RankingMethod::Dominance,
333        }
334    }
335}
336
337impl Default for ParetoExplorationConfig {
338    fn default() -> Self {
339        Self {
340            solution_count: 50,
341            diversity_preservation: true,
342            convergence_criteria: ConvergenceCriteria::default(),
343        }
344    }
345}
346
347impl Default for ConvergenceCriteria {
348    fn default() -> Self {
349        Self {
350            max_iterations: 1000,
351            improvement_threshold: 1e-6,
352            stagnation_tolerance: 50,
353            time_limit: Duration::from_secs(300),
354        }
355    }
356}
357
358impl Default for DynamicWeightingConfig {
359    fn default() -> Self {
360        Self {
361            enable_dynamic: true,
362            adaptation_strategy: WeightingStrategy::PerformanceBased,
363            update_frequency: Duration::from_secs(60),
364            historical_influence: 0.3,
365        }
366    }
367}
368
369impl Default for CacheSizeLimits {
370    fn default() -> Self {
371        Self {
372            circuit_cache_size: 1000,
373            optimization_cache_size: 500,
374            performance_cache_size: 2000,
375            memory_limit_mb: 1024,
376        }
377    }
378}
379
380impl Default for EvictionPolicies {
381    fn default() -> Self {
382        Self {
383            circuit_cache_policy: EvictionPolicy::PerformanceBased,
384            optimization_cache_policy: EvictionPolicy::LRU,
385            performance_cache_policy: EvictionPolicy::LFU,
386        }
387    }
388}
389
390impl Default for CacheLearningConfig {
391    fn default() -> Self {
392        Self {
393            enable_cache_learning: true,
394            pattern_recognition: true,
395            predictive_precaching: true,
396            cache_hit_prediction: true,
397        }
398    }
399}
400
401impl Default for DistributedCachingConfig {
402    fn default() -> Self {
403        Self {
404            enable_distributed: false,
405            consistency_model: ConsistencyModel::EventualConsistency,
406            replication_factor: 3,
407            synchronization_strategy: SynchronizationStrategy::Batch,
408        }
409    }
410}
quantrs2_device/adaptive_compilation/config.rs

quantrs2_device/adaptive_compilation/
config.rs
