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, Default)]
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, Eq)]
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, Eq)]
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, Eq)]
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, Eq)]
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, Eq)]
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, Eq)]
250pub enum ConsistencyModel {
251    StrongConsistency,
252    EventualConsistency,
253    WeakConsistency,
254    SessionConsistency,
255}
256
257/// Cache synchronization strategies
258#[derive(Debug, Clone, PartialEq, Eq)]
259pub enum SynchronizationStrategy {
260    Immediate,
261    Batch,
262    LazyPropagation,
263    ConflictFree,
264}
265
266impl Default for RealtimeOptimizationConfig {
267    fn default() -> Self {
268        Self {
269            enable_realtime: true,
270            update_interval: Duration::from_millis(100),
271            performance_threshold: 0.95,
272            max_optimization_time: Duration::from_secs(30),
273            optimization_algorithms: vec![
274                OptimizationAlgorithm::GradientDescent,
275                OptimizationAlgorithm::BayesianOptimization,
276            ],
277            parallel_optimization: ParallelOptimizationConfig::default(),
278            adaptive_algorithm_selection: true,
279        }
280    }
281}
282
283impl Default for OptimizationObjectivesConfig {
284    fn default() -> Self {
285        let mut primary_objectives = HashMap::new();
286        primary_objectives.insert("fidelity".to_string(), 0.6);
287        primary_objectives.insert("execution_time".to_string(), 0.4);
288
289        Self {
290            primary_objectives,
291            secondary_objectives: HashMap::new(),
292            constraints: vec![],
293            multi_objective: MultiObjectiveConfig::default(),
294            dynamic_weighting: DynamicWeightingConfig::default(),
295        }
296    }
297}
298
299impl Default for CachingLearningConfig {
300    fn default() -> Self {
301        Self {
302            enable_caching: true,
303            cache_size_limits: CacheSizeLimits::default(),
304            eviction_policies: EvictionPolicies::default(),
305            cache_learning: CacheLearningConfig::default(),
306            distributed_caching: DistributedCachingConfig::default(),
307        }
308    }
309}
310
311impl Default for MultiObjectiveConfig {
312    fn default() -> Self {
313        Self {
314            enable_multi_objective: true,
315            pareto_exploration: ParetoExplorationConfig::default(),
316            trade_off_strategies: vec![TradeOffStrategy::NSGA2],
317            ranking_method: RankingMethod::Dominance,
318        }
319    }
320}
321
322impl Default for ParetoExplorationConfig {
323    fn default() -> Self {
324        Self {
325            solution_count: 50,
326            diversity_preservation: true,
327            convergence_criteria: ConvergenceCriteria::default(),
328        }
329    }
330}
331
332impl Default for ConvergenceCriteria {
333    fn default() -> Self {
334        Self {
335            max_iterations: 1000,
336            improvement_threshold: 1e-6,
337            stagnation_tolerance: 50,
338            time_limit: Duration::from_secs(300),
339        }
340    }
341}
342
343impl Default for DynamicWeightingConfig {
344    fn default() -> Self {
345        Self {
346            enable_dynamic: true,
347            adaptation_strategy: WeightingStrategy::PerformanceBased,
348            update_frequency: Duration::from_secs(60),
349            historical_influence: 0.3,
350        }
351    }
352}
353
354impl Default for CacheSizeLimits {
355    fn default() -> Self {
356        Self {
357            circuit_cache_size: 1000,
358            optimization_cache_size: 500,
359            performance_cache_size: 2000,
360            memory_limit_mb: 1024,
361        }
362    }
363}
364
365impl Default for EvictionPolicies {
366    fn default() -> Self {
367        Self {
368            circuit_cache_policy: EvictionPolicy::PerformanceBased,
369            optimization_cache_policy: EvictionPolicy::LRU,
370            performance_cache_policy: EvictionPolicy::LFU,
371        }
372    }
373}
374
375impl Default for CacheLearningConfig {
376    fn default() -> Self {
377        Self {
378            enable_cache_learning: true,
379            pattern_recognition: true,
380            predictive_precaching: true,
381            cache_hit_prediction: true,
382        }
383    }
384}
385
386impl Default for DistributedCachingConfig {
387    fn default() -> Self {
388        Self {
389            enable_distributed: false,
390            consistency_model: ConsistencyModel::EventualConsistency,
391            replication_factor: 3,
392            synchronization_strategy: SynchronizationStrategy::Batch,
393        }
394    }
395}
quantrs2_device/adaptive_compilation/config.rs

quantrs2_device/adaptive_compilation/
config.rs
