quantrs2_device/adaptive_compilation/
hardware_adaptation.rs

1//! Hardware Adaptation and Device-Specific Configuration
2
3use std::collections::HashMap;
4use std::time::Duration;
5
6/// Hardware adaptation configuration
7#[derive(Debug, Clone)]
8pub struct HardwareAdaptationConfig {
9    /// Enable hardware-aware compilation
10    pub enable_hardware_aware: bool,
11    /// Device characterization integration
12    pub device_characterization: DeviceCharacterizationConfig,
13    /// Dynamic calibration adjustment
14    pub dynamic_calibration: DynamicCalibrationConfig,
15    /// Hardware failure handling
16    pub failure_handling: FailureHandlingConfig,
17    /// Resource optimization
18    pub resource_optimization: ResourceOptimizationConfig,
19}
20
21/// Device characterization configuration
22#[derive(Debug, Clone)]
23pub struct DeviceCharacterizationConfig {
24    /// Enable device characterization
25    pub enable_characterization: bool,
26    /// Characterization depth
27    pub characterization_depth: CharacterizationDepth,
28    /// Characterization frequency
29    pub characterization_frequency: Duration,
30    /// Calibration integration
31    pub calibration_integration: CalibrationIntegrationConfig,
32    /// Performance modeling
33    pub performance_modeling: PerformanceModelingConfig,
34}
35
36/// Levels of device characterization
37#[derive(Debug, Clone, PartialEq)]
38pub enum CharacterizationDepth {
39    Basic,
40    Standard,
41    Comprehensive,
42    ExhaustiveCharacterization,
43}
44
45/// Calibration integration configuration
46#[derive(Debug, Clone)]
47pub struct CalibrationIntegrationConfig {
48    /// Enable calibration integration
49    pub enable_integration: bool,
50    /// Real-time calibration updates
51    pub realtime_updates: bool,
52    /// Calibration sources
53    pub calibration_sources: Vec<CalibrationSource>,
54    /// Update strategy
55    pub update_strategy: CalibrationUpdateStrategy,
56}
57
58/// Sources of calibration data
59#[derive(Debug, Clone, PartialEq)]
60pub enum CalibrationSource {
61    DeviceProvider,
62    LocalMeasurement,
63    CommunityDatabase,
64    MachineLearningPrediction,
65    HybridSources,
66}
67
68/// Strategies for calibration updates
69#[derive(Debug, Clone, PartialEq)]
70pub enum CalibrationUpdateStrategy {
71    Immediate,
72    Batch,
73    Scheduled,
74    EventDriven,
75    Adaptive,
76}
77
78/// Performance modeling configuration
79#[derive(Debug, Clone)]
80pub struct PerformanceModelingConfig {
81    /// Enable performance modeling
82    pub enable_modeling: bool,
83    /// Modeling approaches
84    pub modeling_approaches: Vec<ModelingApproach>,
85    /// Model validation
86    pub model_validation: ModelValidationConfig,
87    /// Prediction accuracy requirements
88    pub accuracy_requirements: ModelAccuracyRequirements,
89}
90
91/// Approaches to performance modeling
92#[derive(Debug, Clone, PartialEq)]
93pub enum ModelingApproach {
94    StatisticalModeling,
95    MachineLearningBased,
96    PhysicsInformed,
97    HybridModeling,
98    EmpiricalModeling,
99}
100
101/// Model validation configuration
102#[derive(Debug, Clone)]
103pub struct ModelValidationConfig {
104    /// Validation methods
105    pub validation_methods: Vec<ValidationMethod>,
106    /// Validation frequency
107    pub validation_frequency: Duration,
108    /// Cross-validation setup
109    pub cross_validation: CrossValidationSetup,
110}
111
112/// Model validation methods
113#[derive(Debug, Clone, PartialEq)]
114pub enum ValidationMethod {
115    HoldoutValidation,
116    CrossValidation,
117    BootstrapValidation,
118    TimeSeriesValidation,
119    PhysicsBasedValidation,
120}
121
122/// Cross-validation setup
123#[derive(Debug, Clone)]
124pub struct CrossValidationSetup {
125    /// Number of folds
126    pub folds: usize,
127    /// Stratification strategy
128    pub stratification: StratificationStrategy,
129    /// Temporal considerations
130    pub temporal_considerations: TemporalConsiderations,
131}
132
133/// Stratification strategies
134#[derive(Debug, Clone, PartialEq)]
135pub enum StratificationStrategy {
136    Random,
137    Temporal,
138    DeviceBased,
139    PerformanceBased,
140    Balanced,
141}
142
143/// Temporal considerations for validation
144#[derive(Debug, Clone)]
145pub struct TemporalConsiderations {
146    /// Respect temporal order
147    pub respect_temporal_order: bool,
148    /// Gap between train and test
149    pub temporal_gap: Duration,
150    /// Seasonal adjustments
151    pub seasonal_adjustments: bool,
152}
153
154/// Model accuracy requirements
155#[derive(Debug, Clone)]
156pub struct ModelAccuracyRequirements {
157    /// Minimum R-squared
158    pub min_r_squared: f64,
159    /// Maximum RMSE
160    pub max_rmse: f64,
161    /// Maximum mean absolute error
162    pub max_mae: f64,
163    /// Confidence interval requirements
164    pub confidence_interval: ConfidenceIntervalRequirements,
165}
166
167/// Confidence interval requirements
168#[derive(Debug, Clone)]
169pub struct ConfidenceIntervalRequirements {
170    /// Required confidence level
171    pub confidence_level: f64,
172    /// Maximum interval width
173    pub max_interval_width: f64,
174    /// Coverage requirements
175    pub coverage_requirements: f64,
176}
177
178/// Dynamic calibration configuration
179#[derive(Debug, Clone)]
180pub struct DynamicCalibrationConfig {
181    /// Enable dynamic calibration
182    pub enable_dynamic_calibration: bool,
183    /// Calibration triggers
184    pub calibration_triggers: Vec<CalibrationTrigger>,
185    /// Calibration strategy
186    pub calibration_strategy: CalibrationStrategy,
187    /// Update frequency limits
188    pub frequency_limits: CalibrationFrequencyLimits,
189    /// Quality assurance
190    pub quality_assurance: CalibrationQualityAssurance,
191}
192
193/// Triggers for calibration updates
194#[derive(Debug, Clone, PartialEq)]
195pub enum CalibrationTrigger {
196    TimeInterval,
197    PerformanceDrift,
198    ErrorRateIncrease,
199    TemperatureChange,
200    ManualRequest,
201    AutomaticDetection,
202}
203
204/// Calibration strategies
205#[derive(Debug, Clone, PartialEq)]
206pub enum CalibrationStrategy {
207    FullRecalibration,
208    IncrementalUpdate,
209    SelectiveCalibration,
210    PredictiveCalibration,
211    AdaptiveCalibration,
212}
213
214/// Frequency limits for calibration
215#[derive(Debug, Clone)]
216pub struct CalibrationFrequencyLimits {
217    /// Minimum interval between calibrations
218    pub min_interval: Duration,
219    /// Maximum calibrations per day
220    pub max_per_day: usize,
221    /// Emergency calibration limits
222    pub emergency_limits: EmergencyCalibrationLimits,
223}
224
225/// Emergency calibration limits
226#[derive(Debug, Clone)]
227pub struct EmergencyCalibrationLimits {
228    /// Allow emergency calibration
229    pub allow_emergency: bool,
230    /// Maximum emergency calibrations per hour
231    pub max_emergency_per_hour: usize,
232    /// Emergency threshold
233    pub emergency_threshold: f64,
234}
235
236/// Calibration quality assurance
237#[derive(Debug, Clone)]
238pub struct CalibrationQualityAssurance {
239    /// Quality metrics
240    pub quality_metrics: Vec<CalibrationQualityMetric>,
241    /// Validation requirements
242    pub validation_requirements: CalibrationValidationRequirements,
243    /// Rollback strategy
244    pub rollback_strategy: CalibrationRollbackStrategy,
245}
246
247/// Quality metrics for calibration
248#[derive(Debug, Clone, PartialEq)]
249pub enum CalibrationQualityMetric {
250    Repeatability,
251    Accuracy,
252    Stability,
253    Drift,
254    Consistency,
255}
256
257/// Validation requirements for calibration
258#[derive(Debug, Clone)]
259pub struct CalibrationValidationRequirements {
260    /// Minimum validation samples
261    pub min_validation_samples: usize,
262    /// Validation accuracy threshold
263    pub accuracy_threshold: f64,
264    /// Statistical significance level
265    pub significance_level: f64,
266}
267
268/// Rollback strategies for failed calibration
269#[derive(Debug, Clone, PartialEq)]
270pub enum CalibrationRollbackStrategy {
271    PreviousCalibration,
272    DefaultCalibration,
273    InterpolatedCalibration,
274    ManualIntervention,
275}
276
277/// Failure handling configuration
278#[derive(Debug, Clone)]
279pub struct FailureHandlingConfig {
280    /// Enable failure handling
281    pub enable_failure_handling: bool,
282    /// Failure detection configuration
283    pub failure_detection: FailureDetectionConfig,
284    /// Recovery strategies
285    pub recovery_strategies: Vec<RecoveryStrategy>,
286    /// Escalation procedures
287    pub escalation_procedures: EscalationProcedures,
288}
289
290/// Failure detection configuration
291#[derive(Debug, Clone)]
292pub struct FailureDetectionConfig {
293    /// Detection methods
294    pub detection_methods: Vec<FailureDetectionMethod>,
295    /// Detection sensitivity
296    pub detection_sensitivity: f64,
297    /// Monitoring intervals
298    pub monitoring_intervals: MonitoringIntervals,
299    /// Alert thresholds
300    pub alert_thresholds: AlertThresholds,
301}
302
303/// Methods for detecting hardware failures
304#[derive(Debug, Clone, PartialEq)]
305pub enum FailureDetectionMethod {
306    PerformanceMonitoring,
307    ErrorRateTracking,
308    PatternRecognition,
309    AnomalyDetection,
310    PhysicalSensorMonitoring,
311    StatisticalAnalysis,
312}
313
314/// Monitoring intervals for failure detection
315#[derive(Debug, Clone)]
316pub struct MonitoringIntervals {
317    /// Performance monitoring interval
318    pub performance_interval: Duration,
319    /// Error rate monitoring interval
320    pub error_rate_interval: Duration,
321    /// Health check interval
322    pub health_check_interval: Duration,
323}
324
325/// Alert thresholds for failure detection
326#[derive(Debug, Clone)]
327pub struct AlertThresholds {
328    /// Performance degradation threshold
329    pub performance_threshold: f64,
330    /// Error rate threshold
331    pub error_rate_threshold: f64,
332    /// Anomaly score threshold
333    pub anomaly_threshold: f64,
334}
335
336/// Recovery strategies for hardware failures
337#[derive(Debug, Clone, PartialEq)]
338pub enum RecoveryStrategy {
339    Recalibration,
340    ComponentReset,
341    AlternativeRouting,
342    GracefulDegradation,
343    ServiceReplacement,
344    ManualIntervention,
345}
346
347/// Escalation procedures for failures
348#[derive(Debug, Clone)]
349pub struct EscalationProcedures {
350    /// Escalation levels
351    pub escalation_levels: Vec<EscalationLevel>,
352    /// Escalation timeouts
353    pub escalation_timeouts: HashMap<String, Duration>,
354    /// Notification procedures
355    pub notification_procedures: NotificationProcedures,
356}
357
358/// Escalation levels for failure handling
359#[derive(Debug, Clone)]
360pub struct EscalationLevel {
361    /// Level name
362    pub level_name: String,
363    /// Severity threshold
364    pub severity_threshold: f64,
365    /// Required actions
366    pub required_actions: Vec<String>,
367    /// Responsible parties
368    pub responsible_parties: Vec<String>,
369}
370
371/// Notification procedures for escalation
372#[derive(Debug, Clone)]
373pub struct NotificationProcedures {
374    /// Notification channels
375    pub channels: Vec<NotificationChannel>,
376    /// Notification content templates
377    pub content_templates: HashMap<String, String>,
378    /// Delivery preferences
379    pub delivery_preferences: DeliveryPreferences,
380}
381
382/// Notification delivery channels
383#[derive(Debug, Clone, PartialEq)]
384pub enum NotificationChannel {
385    Email,
386    SMS,
387    Slack,
388    PagerDuty,
389    Dashboard,
390    API,
391}
392
393/// Notification delivery preferences
394#[derive(Debug, Clone)]
395pub struct DeliveryPreferences {
396    /// Priority-based routing
397    pub priority_routing: bool,
398    /// Delivery confirmation required
399    pub confirmation_required: bool,
400    /// Retry attempts
401    pub retry_attempts: usize,
402    /// Retry intervals
403    pub retry_intervals: Vec<Duration>,
404}
405
406/// Resource optimization configuration
407#[derive(Debug, Clone)]
408pub struct ResourceOptimizationConfig {
409    /// Enable resource optimization
410    pub enable_optimization: bool,
411    /// Optimization strategies
412    pub optimization_strategies: Vec<ResourceOptimizationStrategy>,
413    /// Resource allocation
414    pub resource_allocation: ResourceAllocationConfig,
415    /// Load balancing
416    pub load_balancing: LoadBalancingConfig,
417}
418
419/// Resource optimization strategies
420#[derive(Debug, Clone, PartialEq)]
421pub enum ResourceOptimizationStrategy {
422    MinimizeLatency,
423    MaximizeThroughput,
424    MinimizeEnergyConsumption,
425    BalancedOptimization,
426    CustomOptimization(String),
427}
428
429/// Resource allocation configuration
430#[derive(Debug, Clone)]
431pub struct ResourceAllocationConfig {
432    /// Allocation strategy
433    pub allocation_strategy: AllocationStrategy,
434    /// Priority-based allocation
435    pub priority_allocation: PriorityAllocationConfig,
436    /// Dynamic reallocation
437    pub dynamic_reallocation: DynamicReallocationConfig,
438}
439
440/// Resource allocation strategies
441#[derive(Debug, Clone, PartialEq)]
442pub enum AllocationStrategy {
443    FirstFit,
444    BestFit,
445    WorstFit,
446    RoundRobin,
447    PerformanceBased,
448    PredictiveBased,
449}
450
451/// Priority-based allocation configuration
452#[derive(Debug, Clone)]
453pub struct PriorityAllocationConfig {
454    /// Enable priority allocation
455    pub enable_priority: bool,
456    /// Priority levels
457    pub priority_levels: Vec<PriorityLevel>,
458    /// Preemption policy
459    pub preemption_policy: PreemptionPolicy,
460}
461
462/// Priority levels for resource allocation
463#[derive(Debug, Clone)]
464pub struct PriorityLevel {
465    /// Priority name
466    pub name: String,
467    /// Priority value (higher = more important)
468    pub value: i32,
469    /// Resource guarantees
470    pub resource_guarantees: ResourceGuarantees,
471}
472
473/// Resource guarantees for priority levels
474#[derive(Debug, Clone)]
475pub struct ResourceGuarantees {
476    /// Minimum CPU allocation
477    pub min_cpu: f64,
478    /// Minimum memory allocation
479    pub min_memory: f64,
480    /// Maximum latency guarantee
481    pub max_latency: Duration,
482}
483
484/// Preemption policies for resource allocation
485#[derive(Debug, Clone, PartialEq)]
486pub enum PreemptionPolicy {
487    NoPreemption,
488    PriorityBased,
489    FairShare,
490    TimeSlicing,
491    Cooperative,
492}
493
494/// Dynamic reallocation configuration
495#[derive(Debug, Clone)]
496pub struct DynamicReallocationConfig {
497    /// Enable dynamic reallocation
498    pub enable_reallocation: bool,
499    /// Reallocation triggers
500    pub triggers: Vec<ReallocationTrigger>,
501    /// Reallocation frequency
502    pub frequency: ReallocationFrequency,
503    /// Migration strategy
504    pub migration_strategy: MigrationStrategy,
505}
506
507/// Triggers for dynamic reallocation
508#[derive(Debug, Clone, PartialEq)]
509pub enum ReallocationTrigger {
510    LoadImbalance,
511    PerformanceDegradation,
512    ResourceContention,
513    ScheduledMaintenance,
514    ManualRequest,
515}
516
517/// Frequency configuration for reallocation
518#[derive(Debug, Clone)]
519pub struct ReallocationFrequency {
520    /// Base interval
521    pub base_interval: Duration,
522    /// Adaptive frequency
523    pub adaptive_frequency: bool,
524    /// Maximum frequency
525    pub max_frequency: Duration,
526    /// Minimum frequency
527    pub min_frequency: Duration,
528}
529
530/// Migration strategies for reallocation
531#[derive(Debug, Clone, PartialEq)]
532pub enum MigrationStrategy {
533    LiveMigration,
534    CheckpointRestart,
535    GracefulShutdown,
536    ForceTermination,
537}
538
539/// Load balancing configuration
540#[derive(Debug, Clone)]
541pub struct LoadBalancingConfig {
542    /// Enable load balancing
543    pub enable_load_balancing: bool,
544    /// Load balancing algorithms
545    pub algorithms: Vec<LoadBalancingAlgorithm>,
546    /// Health checking
547    pub health_checking: HealthCheckingConfig,
548    /// Traffic distribution
549    pub traffic_distribution: TrafficDistributionConfig,
550}
551
552/// Load balancing algorithms
553#[derive(Debug, Clone, PartialEq)]
554pub enum LoadBalancingAlgorithm {
555    RoundRobin,
556    WeightedRoundRobin,
557    LeastConnections,
558    PerformanceBased,
559    HashBased,
560    AdaptiveBalancing,
561}
562
563/// Health checking configuration
564#[derive(Debug, Clone)]
565pub struct HealthCheckingConfig {
566    /// Health check interval
567    pub check_interval: Duration,
568    /// Health check timeout
569    pub check_timeout: Duration,
570    /// Failure threshold
571    pub failure_threshold: usize,
572    /// Recovery threshold
573    pub recovery_threshold: usize,
574}
575
576/// Traffic distribution configuration
577#[derive(Debug, Clone)]
578pub struct TrafficDistributionConfig {
579    /// Distribution strategy
580    pub strategy: DistributionStrategy,
581    /// Weight assignment
582    pub weight_assignment: WeightAssignmentStrategy,
583    /// Sticky sessions
584    pub sticky_sessions: bool,
585}
586
587/// Traffic distribution strategies
588#[derive(Debug, Clone, PartialEq)]
589pub enum DistributionStrategy {
590    Uniform,
591    Weighted,
592    PerformanceBased,
593    CapacityBased,
594    LatencyBased,
595}
596
597/// Weight assignment strategies
598#[derive(Debug, Clone, PartialEq)]
599pub enum WeightAssignmentStrategy {
600    Static,
601    Dynamic,
602    PerformanceBased,
603    CapacityBased,
604    Historical,
605}
606
607// Default implementations
608
609impl Default for HardwareAdaptationConfig {
610    fn default() -> Self {
611        Self {
612            enable_hardware_aware: true,
613            device_characterization: DeviceCharacterizationConfig::default(),
614            dynamic_calibration: DynamicCalibrationConfig::default(),
615            failure_handling: FailureHandlingConfig::default(),
616            resource_optimization: ResourceOptimizationConfig::default(),
617        }
618    }
619}
620
621impl Default for DeviceCharacterizationConfig {
622    fn default() -> Self {
623        Self {
624            enable_characterization: true,
625            characterization_depth: CharacterizationDepth::Standard,
626            characterization_frequency: Duration::from_secs(3600), // 1 hour
627            calibration_integration: CalibrationIntegrationConfig::default(),
628            performance_modeling: PerformanceModelingConfig::default(),
629        }
630    }
631}
632
633impl Default for CalibrationIntegrationConfig {
634    fn default() -> Self {
635        Self {
636            enable_integration: true,
637            realtime_updates: true,
638            calibration_sources: vec![
639                CalibrationSource::DeviceProvider,
640                CalibrationSource::LocalMeasurement,
641            ],
642            update_strategy: CalibrationUpdateStrategy::Adaptive,
643        }
644    }
645}
646
647impl Default for PerformanceModelingConfig {
648    fn default() -> Self {
649        Self {
650            enable_modeling: true,
651            modeling_approaches: vec![
652                ModelingApproach::StatisticalModeling,
653                ModelingApproach::MachineLearningBased,
654            ],
655            model_validation: ModelValidationConfig::default(),
656            accuracy_requirements: ModelAccuracyRequirements::default(),
657        }
658    }
659}
660
661impl Default for ModelValidationConfig {
662    fn default() -> Self {
663        Self {
664            validation_methods: vec![ValidationMethod::CrossValidation],
665            validation_frequency: Duration::from_secs(86400), // 24 hours
666            cross_validation: CrossValidationSetup::default(),
667        }
668    }
669}
670
671impl Default for CrossValidationSetup {
672    fn default() -> Self {
673        Self {
674            folds: 5,
675            stratification: StratificationStrategy::Random,
676            temporal_considerations: TemporalConsiderations::default(),
677        }
678    }
679}
680
681impl Default for TemporalConsiderations {
682    fn default() -> Self {
683        Self {
684            respect_temporal_order: true,
685            temporal_gap: Duration::from_secs(300), // 5 minutes
686            seasonal_adjustments: false,
687        }
688    }
689}
690
691impl Default for ModelAccuracyRequirements {
692    fn default() -> Self {
693        Self {
694            min_r_squared: 0.8,
695            max_rmse: 0.1,
696            max_mae: 0.05,
697            confidence_interval: ConfidenceIntervalRequirements::default(),
698        }
699    }
700}
701
702impl Default for ConfidenceIntervalRequirements {
703    fn default() -> Self {
704        Self {
705            confidence_level: 0.95,
706            max_interval_width: 0.2,
707            coverage_requirements: 0.95,
708        }
709    }
710}
711
712impl Default for DynamicCalibrationConfig {
713    fn default() -> Self {
714        Self {
715            enable_dynamic_calibration: true,
716            calibration_triggers: vec![
717                CalibrationTrigger::TimeInterval,
718                CalibrationTrigger::PerformanceDrift,
719            ],
720            calibration_strategy: CalibrationStrategy::AdaptiveCalibration,
721            frequency_limits: CalibrationFrequencyLimits::default(),
722            quality_assurance: CalibrationQualityAssurance::default(),
723        }
724    }
725}
726
727impl Default for CalibrationFrequencyLimits {
728    fn default() -> Self {
729        Self {
730            min_interval: Duration::from_secs(300), // 5 minutes
731            max_per_day: 48,
732            emergency_limits: EmergencyCalibrationLimits::default(),
733        }
734    }
735}
736
737impl Default for EmergencyCalibrationLimits {
738    fn default() -> Self {
739        Self {
740            allow_emergency: true,
741            max_emergency_per_hour: 3,
742            emergency_threshold: 0.01, // 1% performance degradation
743        }
744    }
745}
746
747impl Default for CalibrationQualityAssurance {
748    fn default() -> Self {
749        Self {
750            quality_metrics: vec![
751                CalibrationQualityMetric::Accuracy,
752                CalibrationQualityMetric::Repeatability,
753            ],
754            validation_requirements: CalibrationValidationRequirements::default(),
755            rollback_strategy: CalibrationRollbackStrategy::PreviousCalibration,
756        }
757    }
758}
759
760impl Default for CalibrationValidationRequirements {
761    fn default() -> Self {
762        Self {
763            min_validation_samples: 10,
764            accuracy_threshold: 0.95,
765            significance_level: 0.05,
766        }
767    }
768}
769
770impl Default for FailureHandlingConfig {
771    fn default() -> Self {
772        Self {
773            enable_failure_handling: true,
774            failure_detection: FailureDetectionConfig::default(),
775            recovery_strategies: vec![
776                RecoveryStrategy::Recalibration,
777                RecoveryStrategy::GracefulDegradation,
778            ],
779            escalation_procedures: EscalationProcedures::default(),
780        }
781    }
782}
783
784impl Default for FailureDetectionConfig {
785    fn default() -> Self {
786        Self {
787            detection_methods: vec![
788                FailureDetectionMethod::PerformanceMonitoring,
789                FailureDetectionMethod::ErrorRateTracking,
790            ],
791            detection_sensitivity: 0.95,
792            monitoring_intervals: MonitoringIntervals::default(),
793            alert_thresholds: AlertThresholds::default(),
794        }
795    }
796}
797
798impl Default for MonitoringIntervals {
799    fn default() -> Self {
800        Self {
801            performance_interval: Duration::from_secs(60),
802            error_rate_interval: Duration::from_secs(30),
803            health_check_interval: Duration::from_secs(300),
804        }
805    }
806}
807
808impl Default for AlertThresholds {
809    fn default() -> Self {
810        Self {
811            performance_threshold: 0.1, // 10% degradation
812            error_rate_threshold: 0.05, // 5% error rate
813            anomaly_threshold: 2.0,     // 2 standard deviations
814        }
815    }
816}
817
818impl Default for EscalationProcedures {
819    fn default() -> Self {
820        Self {
821            escalation_levels: vec![],
822            escalation_timeouts: HashMap::new(),
823            notification_procedures: NotificationProcedures::default(),
824        }
825    }
826}
827
828impl Default for NotificationProcedures {
829    fn default() -> Self {
830        Self {
831            channels: vec![NotificationChannel::Dashboard],
832            content_templates: HashMap::new(),
833            delivery_preferences: DeliveryPreferences::default(),
834        }
835    }
836}
837
838impl Default for DeliveryPreferences {
839    fn default() -> Self {
840        Self {
841            priority_routing: true,
842            confirmation_required: false,
843            retry_attempts: 3,
844            retry_intervals: vec![
845                Duration::from_secs(60),
846                Duration::from_secs(300),
847                Duration::from_secs(900),
848            ],
849        }
850    }
851}
852
853impl Default for ResourceOptimizationConfig {
854    fn default() -> Self {
855        Self {
856            enable_optimization: true,
857            optimization_strategies: vec![ResourceOptimizationStrategy::BalancedOptimization],
858            resource_allocation: ResourceAllocationConfig::default(),
859            load_balancing: LoadBalancingConfig::default(),
860        }
861    }
862}
863
864impl Default for ResourceAllocationConfig {
865    fn default() -> Self {
866        Self {
867            allocation_strategy: AllocationStrategy::PerformanceBased,
868            priority_allocation: PriorityAllocationConfig::default(),
869            dynamic_reallocation: DynamicReallocationConfig::default(),
870        }
871    }
872}
873
874impl Default for PriorityAllocationConfig {
875    fn default() -> Self {
876        Self {
877            enable_priority: true,
878            priority_levels: vec![],
879            preemption_policy: PreemptionPolicy::PriorityBased,
880        }
881    }
882}
883
884impl Default for DynamicReallocationConfig {
885    fn default() -> Self {
886        Self {
887            enable_reallocation: true,
888            triggers: vec![
889                ReallocationTrigger::LoadImbalance,
890                ReallocationTrigger::PerformanceDegradation,
891            ],
892            frequency: ReallocationFrequency::default(),
893            migration_strategy: MigrationStrategy::LiveMigration,
894        }
895    }
896}
897
898impl Default for ReallocationFrequency {
899    fn default() -> Self {
900        Self {
901            base_interval: Duration::from_secs(300),
902            adaptive_frequency: true,
903            max_frequency: Duration::from_secs(60),
904            min_frequency: Duration::from_secs(3600),
905        }
906    }
907}
908
909impl Default for LoadBalancingConfig {
910    fn default() -> Self {
911        Self {
912            enable_load_balancing: true,
913            algorithms: vec![LoadBalancingAlgorithm::PerformanceBased],
914            health_checking: HealthCheckingConfig::default(),
915            traffic_distribution: TrafficDistributionConfig::default(),
916        }
917    }
918}
919
920impl Default for HealthCheckingConfig {
921    fn default() -> Self {
922        Self {
923            check_interval: Duration::from_secs(30),
924            check_timeout: Duration::from_secs(5),
925            failure_threshold: 3,
926            recovery_threshold: 2,
927        }
928    }
929}
930
931impl Default for TrafficDistributionConfig {
932    fn default() -> Self {
933        Self {
934            strategy: DistributionStrategy::PerformanceBased,
935            weight_assignment: WeightAssignmentStrategy::Dynamic,
936            sticky_sessions: false,
937        }
938    }
939}
quantrs2_device/adaptive_compilation/hardware_adaptation.rs

quantrs2_device/adaptive_compilation/
hardware_adaptation.rs
