quantrs2_device/hardware_parallelization/
config.rs

1//! Hardware-Aware Quantum Circuit Parallelization
2//!
3//! This module provides sophisticated parallelization capabilities that understand
4//! and respect hardware constraints, topology, and resource limitations to maximize
5//! throughput while maintaining circuit fidelity and correctness.
6
7use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
8use std::sync::{Arc, Mutex, RwLock};
9use std::time::{Duration, Instant, SystemTime};
10
11use quantrs2_circuit::prelude::*;
12use quantrs2_core::{
13    error::{QuantRS2Error, QuantRS2Result},
14    gate::GateOp,
15    platform::PlatformCapabilities,
16    qubit::QubitId,
17};
18
19// SciRS2 integration for advanced parallelization analysis
20#[cfg(feature = "scirs2")]
21use scirs2_graph::{
22    betweenness_centrality, closeness_centrality, dijkstra_path, minimum_spanning_tree,
23    strongly_connected_components, topological_sort, Graph,
24};
25#[cfg(feature = "scirs2")]
26use scirs2_optimize::{differential_evolution, minimize, OptimizeResult};
27#[cfg(feature = "scirs2")]
28use scirs2_stats::{corrcoef, mean, pearsonr, std};
29
30use scirs2_core::ndarray::{Array1, Array2, ArrayView1, ArrayView2};
31use serde::{Deserialize, Serialize};
32use tokio::sync::{Mutex as AsyncMutex, RwLock as AsyncRwLock, Semaphore};
33
34use crate::{
35    backend_traits::{query_backend_capabilities, BackendCapabilities},
36    calibration::{CalibrationManager, DeviceCalibration},
37    integrated_device_manager::{DeviceInfo, IntegratedQuantumDeviceManager},
38    routing_advanced::{AdvancedQubitRouter, AdvancedRoutingResult},
39    topology::HardwareTopology,
40    translation::HardwareBackend,
41    DeviceError, DeviceResult,
42};
43
44/// Hardware-aware parallelization configuration
45#[derive(Debug, Clone, Serialize, Deserialize)]
46pub struct ParallelizationConfig {
47    /// Parallelization strategy
48    pub strategy: ParallelizationStrategy,
49    /// Resource allocation settings
50    pub resource_allocation: ResourceAllocationConfig,
51    /// Scheduling configuration
52    pub scheduling_config: ParallelSchedulingConfig,
53    /// Hardware awareness settings
54    pub hardware_awareness: HardwareAwarenessConfig,
55    /// Performance optimization settings
56    pub performance_config: PerformanceOptimizationConfig,
57    /// Load balancing configuration
58    pub load_balancing: LoadBalancingConfig,
59    /// Resource monitoring settings
60    pub monitoring_config: ResourceMonitoringConfig,
61}
62
63/// Parallelization strategies
64#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
65pub enum ParallelizationStrategy {
66    /// Circuit-level parallelization (multiple independent circuits)
67    CircuitLevel,
68    /// Gate-level parallelization (parallel gate execution)
69    GateLevel,
70    /// Hybrid approach combining both strategies
71    Hybrid,
72    /// Topology-aware parallelization
73    TopologyAware,
74    /// Resource-constrained parallelization
75    ResourceConstrained,
76    /// SciRS2-powered intelligent parallelization
77    SciRS2Optimized,
78    /// Custom strategy with specific parameters
79    Custom {
80        circuit_concurrency: usize,
81        gate_concurrency: usize,
82        resource_weights: HashMap<String, f64>,
83    },
84}
85
86/// Resource allocation configuration
87#[derive(Debug, Clone, Serialize, Deserialize)]
88pub struct ResourceAllocationConfig {
89    /// Maximum concurrent circuits
90    pub max_concurrent_circuits: usize,
91    /// Maximum concurrent gates per circuit
92    pub max_concurrent_gates: usize,
93    /// CPU core allocation strategy
94    pub cpu_allocation: CpuAllocationStrategy,
95    /// Memory allocation limits
96    pub memory_limits: MemoryLimits,
97    /// QPU resource allocation
98    pub qpu_allocation: QpuAllocationConfig,
99    /// Network bandwidth allocation
100    pub network_allocation: NetworkAllocationConfig,
101}
102
103/// CPU allocation strategies
104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
105pub enum CpuAllocationStrategy {
106    /// Use all available cores
107    AllCores,
108    /// Use fixed number of cores
109    FixedCores(usize),
110    /// Use percentage of available cores
111    PercentageCores(f64),
112    /// Adaptive allocation based on load
113    Adaptive,
114    /// NUMA-aware allocation
115    NumaAware,
116}
117
118/// Memory allocation limits
119#[derive(Debug, Clone, Serialize, Deserialize)]
120pub struct MemoryLimits {
121    /// Maximum total memory usage (MB)
122    pub max_total_memory_mb: f64,
123    /// Maximum memory per circuit (MB)
124    pub max_per_circuit_mb: f64,
125    /// Memory allocation strategy
126    pub allocation_strategy: MemoryAllocationStrategy,
127    /// Enable memory pooling
128    pub enable_pooling: bool,
129    /// Garbage collection threshold
130    pub gc_threshold: f64,
131}
132
133/// Memory allocation strategies
134#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
135pub enum MemoryAllocationStrategy {
136    /// Static allocation upfront
137    Static,
138    /// Dynamic allocation as needed
139    Dynamic,
140    /// Pooled allocation with reuse
141    Pooled,
142    /// Adaptive based on circuit complexity
143    Adaptive,
144}
145
146/// QPU resource allocation configuration
147#[derive(Debug, Clone, Serialize, Deserialize)]
148pub struct QpuAllocationConfig {
149    /// Maximum QPU time per circuit
150    pub max_qpu_time_per_circuit: Duration,
151    /// QPU sharing strategy
152    pub sharing_strategy: QpuSharingStrategy,
153    /// Queue management
154    pub queue_management: QueueManagementConfig,
155    /// Fairness parameters
156    pub fairness_config: FairnessConfig,
157}
158
159/// QPU sharing strategies
160#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
161pub enum QpuSharingStrategy {
162    /// Time slicing
163    TimeSlicing,
164    /// Space slicing (using different qubits)
165    SpaceSlicing,
166    /// Hybrid time/space slicing
167    HybridSlicing,
168    /// Exclusive access
169    Exclusive,
170    /// Best effort sharing
171    BestEffort,
172}
173
174/// Queue management configuration
175#[derive(Debug, Clone, Serialize, Deserialize)]
176pub struct QueueManagementConfig {
177    /// Queue scheduling algorithm
178    pub algorithm: QueueSchedulingAlgorithm,
179    /// Maximum queue size
180    pub max_queue_size: usize,
181    /// Priority levels
182    pub priority_levels: usize,
183    /// Enable preemption
184    pub enable_preemption: bool,
185    /// Timeout settings
186    pub timeout_config: TimeoutConfig,
187}
188
189/// Queue scheduling algorithms
190#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
191pub enum QueueSchedulingAlgorithm {
192    /// First-come, first-served
193    FCFS,
194    /// Shortest job first
195    SJF,
196    /// Priority-based scheduling
197    Priority,
198    /// Round-robin
199    RoundRobin,
200    /// Multilevel feedback queue
201    MLFQ,
202    /// SciRS2-optimized scheduling
203    SciRS2Optimized,
204}
205
206/// Timeout configuration
207#[derive(Debug, Clone, Serialize, Deserialize)]
208pub struct TimeoutConfig {
209    /// Circuit execution timeout
210    pub execution_timeout: Duration,
211    /// Queue wait timeout
212    pub queue_timeout: Duration,
213    /// Resource acquisition timeout
214    pub resource_timeout: Duration,
215    /// Enable adaptive timeouts
216    pub adaptive_timeouts: bool,
217}
218
219/// Fairness configuration
220#[derive(Debug, Clone, Serialize, Deserialize)]
221pub struct FairnessConfig {
222    /// Fairness algorithm
223    pub algorithm: FairnessAlgorithm,
224    /// Resource quotas per user/circuit
225    pub resource_quotas: ResourceQuotas,
226    /// Aging factor for starvation prevention
227    pub aging_factor: f64,
228    /// Enable burst allowances
229    pub enable_burst_allowances: bool,
230}
231
232/// Fairness algorithms
233#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
234pub enum FairnessAlgorithm {
235    /// Proportional fair sharing
236    ProportionalFair,
237    /// Max-min fairness
238    MaxMinFair,
239    /// Weighted fair queuing
240    WeightedFairQueuing,
241    /// Lottery scheduling
242    LotteryScheduling,
243    /// Game-theoretic fair scheduling
244    GameTheoretic,
245}
246
247/// Resource quotas
248#[derive(Debug, Clone, Serialize, Deserialize)]
249pub struct ResourceQuotas {
250    /// CPU time quota per user
251    pub cpu_quota: Option<Duration>,
252    /// QPU time quota per user
253    pub qpu_quota: Option<Duration>,
254    /// Memory quota per user (MB)
255    pub memory_quota: Option<f64>,
256    /// Circuit count quota per user
257    pub circuit_quota: Option<usize>,
258}
259
260/// Network allocation configuration
261#[derive(Debug, Clone, Serialize, Deserialize)]
262pub struct NetworkAllocationConfig {
263    /// Maximum bandwidth per circuit (Mbps)
264    pub max_bandwidth_per_circuit: f64,
265    /// Network QoS class
266    pub qos_class: NetworkQoSClass,
267    /// Compression settings
268    pub compression_config: CompressionConfig,
269    /// Latency optimization
270    pub latency_optimization: bool,
271}
272
273/// Network QoS classes
274#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
275pub enum NetworkQoSClass {
276    /// Best effort
277    BestEffort,
278    /// Assured forwarding
279    AssuredForwarding,
280    /// Expedited forwarding
281    ExpeditedForwarding,
282    /// Real-time
283    RealTime,
284}
285
286/// Compression configuration
287#[derive(Debug, Clone, Serialize, Deserialize)]
288pub struct CompressionConfig {
289    /// Enable compression
290    pub enabled: bool,
291    /// Compression algorithm
292    pub algorithm: CompressionAlgorithm,
293    /// Compression level (0-9)
294    pub level: u8,
295    /// Minimum size threshold for compression
296    pub size_threshold: usize,
297}
298
299/// Compression algorithms
300#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
301pub enum CompressionAlgorithm {
302    /// Gzip compression
303    Gzip,
304    /// Zstd compression
305    Zstd,
306    /// LZ4 compression
307    LZ4,
308    /// Brotli compression
309    Brotli,
310}
311
312/// Parallel scheduling configuration
313#[derive(Debug, Clone, Serialize, Deserialize)]
314pub struct ParallelSchedulingConfig {
315    /// Scheduling algorithm
316    pub algorithm: ParallelSchedulingAlgorithm,
317    /// Work stealing configuration
318    pub work_stealing: WorkStealingConfig,
319    /// Load balancing parameters
320    pub load_balancing_params: LoadBalancingParams,
321    /// Thread pool configuration
322    pub thread_pool_config: ThreadPoolConfig,
323}
324
325/// Parallel scheduling algorithms
326#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
327pub enum ParallelSchedulingAlgorithm {
328    /// Work stealing
329    WorkStealing,
330    /// Work sharing
331    WorkSharing,
332    /// Fork-join
333    ForkJoin,
334    /// Actor model
335    ActorModel,
336    /// Pipeline parallelism
337    Pipeline,
338    /// Data parallelism
339    DataParallel,
340    /// Task parallelism
341    TaskParallel,
342}
343
344/// Work stealing configuration
345#[derive(Debug, Clone, Serialize, Deserialize)]
346pub struct WorkStealingConfig {
347    /// Enable work stealing
348    pub enabled: bool,
349    /// Stealing strategy
350    pub strategy: WorkStealingStrategy,
351    /// Queue size per worker
352    pub queue_size: usize,
353    /// Stealing threshold
354    pub stealing_threshold: f64,
355}
356
357/// Work stealing strategies
358#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
359pub enum WorkStealingStrategy {
360    /// Random stealing
361    Random,
362    /// Round-robin stealing
363    RoundRobin,
364    /// Load-based stealing
365    LoadBased,
366    /// Locality-aware stealing
367    LocalityAware,
368}
369
370/// Load balancing parameters
371#[derive(Debug, Clone, Serialize, Deserialize)]
372pub struct LoadBalancingParams {
373    /// Rebalancing frequency
374    pub rebalancing_frequency: Duration,
375    /// Load threshold for rebalancing
376    pub load_threshold: f64,
377    /// Migration cost factor
378    pub migration_cost_factor: f64,
379    /// Enable adaptive load balancing
380    pub adaptive_balancing: bool,
381}
382
383/// Thread pool configuration
384#[derive(Debug, Clone, Serialize, Deserialize)]
385pub struct ThreadPoolConfig {
386    /// Core thread count
387    pub core_threads: usize,
388    /// Maximum thread count
389    pub max_threads: usize,
390    /// Keep-alive time for idle threads
391    pub keep_alive_time: Duration,
392    /// Thread priority
393    pub thread_priority: ThreadPriority,
394    /// Thread affinity settings
395    pub affinity_config: ThreadAffinityConfig,
396}
397
398/// Thread priority levels
399#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
400pub enum ThreadPriority {
401    /// Low priority
402    Low,
403    /// Normal priority
404    Normal,
405    /// High priority
406    High,
407    /// Real-time priority
408    RealTime,
409}
410
411/// Thread affinity configuration
412#[derive(Debug, Clone, Serialize, Deserialize)]
413pub struct ThreadAffinityConfig {
414    /// Enable CPU affinity
415    pub enabled: bool,
416    /// CPU core assignment strategy
417    pub assignment_strategy: CoreAssignmentStrategy,
418    /// NUMA node preference
419    pub numa_preference: NumaPreference,
420}
421
422/// Core assignment strategies
423#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
424pub enum CoreAssignmentStrategy {
425    /// Automatic assignment
426    Automatic,
427    /// Fixed core assignment
428    Fixed(Vec<usize>),
429    /// Round-robin assignment
430    RoundRobin,
431    /// Load-based assignment
432    LoadBased,
433}
434
435/// NUMA preferences
436#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
437pub enum NumaPreference {
438    /// No preference
439    None,
440    /// Local node preferred
441    LocalNode,
442    /// Specific node
443    SpecificNode(usize),
444    /// Interleaved across nodes
445    Interleaved,
446}
447
448/// Hardware awareness configuration
449#[derive(Debug, Clone, Serialize, Deserialize)]
450pub struct HardwareAwarenessConfig {
451    /// Topology awareness level
452    pub topology_awareness: TopologyAwarenessLevel,
453    /// Calibration integration
454    pub calibration_integration: CalibrationIntegrationConfig,
455    /// Error rate consideration
456    pub error_rate_config: ErrorRateConfig,
457    /// Connectivity constraints
458    pub connectivity_config: ConnectivityConfig,
459    /// Resource usage tracking
460    pub resource_tracking: ResourceTrackingConfig,
461}
462
463/// Topology awareness levels
464#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
465pub enum TopologyAwarenessLevel {
466    /// Basic awareness (qubit count only)
467    Basic,
468    /// Connectivity aware
469    Connectivity,
470    /// Calibration aware
471    Calibration,
472    /// Full topology optimization
473    Full,
474    /// SciRS2-powered topology analysis
475    SciRS2Enhanced,
476}
477
478/// Calibration integration configuration
479#[derive(Debug, Clone, Serialize, Deserialize)]
480pub struct CalibrationIntegrationConfig {
481    /// Use real-time calibration data
482    pub use_realtime_calibration: bool,
483    /// Calibration update frequency
484    pub update_frequency: Duration,
485    /// Quality threshold for gate selection
486    pub quality_threshold: f64,
487    /// Enable predictive calibration
488    pub enable_predictive: bool,
489}
490
491/// Error rate configuration
492#[derive(Debug, Clone, Serialize, Deserialize)]
493pub struct ErrorRateConfig {
494    /// Consider error rates in scheduling
495    pub consider_error_rates: bool,
496    /// Error rate threshold
497    pub error_threshold: f64,
498    /// Error mitigation strategy
499    pub mitigation_strategy: ErrorMitigationStrategy,
500    /// Error prediction model
501    pub prediction_model: ErrorPredictionModel,
502}
503
504/// Error mitigation strategies
505#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
506pub enum ErrorMitigationStrategy {
507    /// No mitigation
508    None,
509    /// Retry on high error
510    Retry,
511    /// Dynamical decoupling
512    DynamicalDecoupling,
513    /// Zero-noise extrapolation
514    ZeroNoiseExtrapolation,
515    /// Composite mitigation
516    Composite,
517}
518
519/// Error prediction models
520#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
521pub enum ErrorPredictionModel {
522    /// Static error model
523    Static,
524    /// Time-dependent model
525    TimeDependent,
526    /// Machine learning model
527    MachineLearning,
528    /// Physics-based model
529    PhysicsBased,
530}
531
532/// Connectivity configuration
533#[derive(Debug, Clone, Serialize, Deserialize)]
534pub struct ConnectivityConfig {
535    /// Enforce connectivity constraints
536    pub enforce_constraints: bool,
537    /// SWAP insertion strategy
538    pub swap_strategy: SwapInsertionStrategy,
539    /// Routing algorithm preference
540    pub routing_preference: RoutingPreference,
541    /// Connectivity optimization
542    pub optimization_config: ConnectivityOptimizationConfig,
543}
544
545/// SWAP insertion strategies
546#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
547pub enum SwapInsertionStrategy {
548    /// Minimal SWAP insertion
549    Minimal,
550    /// Lookahead SWAP insertion
551    Lookahead,
552    /// Global optimization
553    GlobalOptimal,
554    /// Heuristic-based
555    Heuristic,
556}
557
558/// Routing preferences
559#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
560pub enum RoutingPreference {
561    /// Shortest path
562    ShortestPath,
563    /// Minimum congestion
564    MinimumCongestion,
565    /// Load balancing
566    LoadBalancing,
567    /// Quality-aware routing
568    QualityAware,
569}
570
571/// Connectivity optimization configuration
572#[derive(Debug, Clone, Serialize, Deserialize)]
573pub struct ConnectivityOptimizationConfig {
574    /// Enable parallel routing
575    pub enable_parallel_routing: bool,
576    /// Routing optimization level
577    pub optimization_level: OptimizationLevel,
578    /// Use machine learning for routing
579    pub use_ml_routing: bool,
580    /// Precompute routing tables
581    pub precompute_tables: bool,
582}
583
584/// Optimization levels
585#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
586pub enum OptimizationLevel {
587    /// No optimization
588    None,
589    /// Basic optimization
590    Basic,
591    /// Moderate optimization
592    Moderate,
593    /// Aggressive optimization
594    Aggressive,
595    /// Experimental optimization
596    Experimental,
597}
598
599/// Resource tracking configuration
600#[derive(Debug, Clone, Serialize, Deserialize)]
601pub struct ResourceTrackingConfig {
602    /// Enable CPU usage tracking
603    pub track_cpu_usage: bool,
604    /// Enable memory usage tracking
605    pub track_memory_usage: bool,
606    /// Enable QPU usage tracking
607    pub track_qpu_usage: bool,
608    /// Enable network usage tracking
609    pub track_network_usage: bool,
610    /// Tracking granularity
611    pub tracking_granularity: TrackingGranularity,
612    /// Reporting frequency
613    pub reporting_frequency: Duration,
614}
615
616/// Tracking granularity levels
617#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
618pub enum TrackingGranularity {
619    /// Coarse-grained (per circuit)
620    Coarse,
621    /// Medium-grained (per gate group)
622    Medium,
623    /// Fine-grained (per gate)
624    Fine,
625    /// Ultra-fine (per operation)
626    UltraFine,
627}
628
629/// Performance optimization configuration
630#[derive(Debug, Clone, Serialize, Deserialize)]
631pub struct PerformanceOptimizationConfig {
632    /// Optimization objectives
633    pub objectives: Vec<OptimizationObjective>,
634    /// Caching configuration
635    pub caching_config: CachingConfig,
636    /// Prefetching settings
637    pub prefetching_config: PrefetchingConfig,
638    /// Batch processing settings
639    pub batch_config: BatchProcessingConfig,
640    /// Adaptive optimization
641    pub adaptive_config: AdaptiveOptimizationConfig,
642}
643
644/// Optimization objectives
645#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
646pub enum OptimizationObjective {
647    /// Minimize execution time
648    MinimizeTime,
649    /// Maximize throughput
650    MaximizeThroughput,
651    /// Minimize resource usage
652    MinimizeResources,
653    /// Maximize quality
654    MaximizeQuality,
655    /// Minimize cost
656    MinimizeCost,
657    /// Minimize energy consumption
658    MinimizeEnergy,
659    /// Balanced optimization
660    Balanced,
661}
662
663/// Caching configuration
664#[derive(Debug, Clone, Serialize, Deserialize)]
665pub struct CachingConfig {
666    /// Enable result caching
667    pub enable_result_caching: bool,
668    /// Enable compilation caching
669    pub enable_compilation_caching: bool,
670    /// Cache size limits
671    pub size_limits: CacheSizeLimits,
672    /// Cache eviction policy
673    pub eviction_policy: CacheEvictionPolicy,
674    /// Cache warming strategies
675    pub warming_strategies: Vec<CacheWarmingStrategy>,
676}
677
678/// Cache size limits
679#[derive(Debug, Clone, Serialize, Deserialize)]
680pub struct CacheSizeLimits {
681    /// Maximum cache entries
682    pub max_entries: usize,
683    /// Maximum memory usage (MB)
684    pub max_memory_mb: f64,
685    /// Maximum disk usage (MB)
686    pub max_disk_mb: f64,
687    /// Per-user cache limits
688    pub per_user_limits: Option<Box<Self>>,
689}
690
691/// Cache eviction policies
692#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
693pub enum CacheEvictionPolicy {
694    /// Least recently used
695    LRU,
696    /// Least frequently used
697    LFU,
698    /// First in, first out
699    FIFO,
700    /// Random eviction
701    Random,
702    /// Time-based expiration
703    TimeExpiration,
704    /// Size-based eviction
705    SizeBased,
706}
707
708/// Cache warming strategies
709#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
710pub enum CacheWarmingStrategy {
711    /// Preload common circuits
712    PreloadCommon,
713    /// Predictive preloading
714    Predictive,
715    /// User pattern based
716    UserPatternBased,
717    /// Background warming
718    Background,
719}
720
721/// Prefetching configuration
722#[derive(Debug, Clone, Serialize, Deserialize)]
723pub struct PrefetchingConfig {
724    /// Enable prefetching
725    pub enabled: bool,
726    /// Prefetching strategy
727    pub strategy: PrefetchingStrategy,
728    /// Prefetch distance
729    pub prefetch_distance: usize,
730    /// Prefetch confidence threshold
731    pub confidence_threshold: f64,
732}
733
734/// Prefetching strategies
735#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
736pub enum PrefetchingStrategy {
737    /// Sequential prefetching
738    Sequential,
739    /// Pattern-based prefetching
740    PatternBased,
741    /// Machine learning prefetching
742    MachineLearning,
743    /// Adaptive prefetching
744    Adaptive,
745}
746
747/// Batch processing configuration
748#[derive(Debug, Clone, Serialize, Deserialize)]
749pub struct BatchProcessingConfig {
750    /// Enable batch processing
751    pub enabled: bool,
752    /// Batch size limits
753    pub size_limits: BatchSizeLimits,
754    /// Batching strategy
755    pub strategy: BatchingStrategy,
756    /// Batch timeout
757    pub timeout: Duration,
758}
759
760/// Batch size limits
761#[derive(Debug, Clone, Serialize, Deserialize)]
762pub struct BatchSizeLimits {
763    /// Minimum batch size
764    pub min_size: usize,
765    /// Maximum batch size
766    pub max_size: usize,
767    /// Optimal batch size
768    pub optimal_size: usize,
769    /// Dynamic sizing
770    pub dynamic_sizing: bool,
771}
772
773/// Batching strategies
774#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
775pub enum BatchingStrategy {
776    /// Fixed size batching
777    FixedSize,
778    /// Time-based batching
779    TimeBased,
780    /// Adaptive batching
781    Adaptive,
782    /// Circuit similarity batching
783    SimilarityBased,
784    /// Resource-aware batching
785    ResourceAware,
786}
787
788/// Adaptive optimization configuration
789#[derive(Debug, Clone, Serialize, Deserialize)]
790pub struct AdaptiveOptimizationConfig {
791    /// Enable adaptive optimization
792    pub enabled: bool,
793    /// Adaptation frequency
794    pub adaptation_frequency: Duration,
795    /// Performance monitoring window
796    pub monitoring_window: Duration,
797    /// Adaptation sensitivity
798    pub sensitivity: f64,
799    /// Machine learning config
800    pub ml_config: AdaptiveMLConfig,
801}
802
803/// Adaptive machine learning configuration
804#[derive(Debug, Clone, Serialize, Deserialize)]
805pub struct AdaptiveMLConfig {
806    /// Enable ML-based adaptation
807    pub enabled: bool,
808    /// ML model type
809    pub model_type: MLModelType,
810    /// Training frequency
811    pub training_frequency: Duration,
812    /// Feature engineering config
813    pub feature_config: FeatureEngineeringConfig,
814}
815
816/// ML model types
817#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
818pub enum MLModelType {
819    /// Linear regression
820    LinearRegression,
821    /// Random forest
822    RandomForest,
823    /// Neural network
824    NeuralNetwork,
825    /// Reinforcement learning
826    ReinforcementLearning,
827    /// Ensemble methods
828    Ensemble,
829}
830
831/// Feature engineering configuration
832#[derive(Debug, Clone, Serialize, Deserialize)]
833pub struct FeatureEngineeringConfig {
834    /// Circuit features to extract
835    pub circuit_features: Vec<CircuitFeature>,
836    /// Hardware features to extract
837    pub hardware_features: Vec<HardwareFeature>,
838    /// Performance features to extract
839    pub performance_features: Vec<PerformanceFeature>,
840    /// Feature normalization
841    pub normalization: FeatureNormalization,
842}
843
844/// Circuit features
845#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
846pub enum CircuitFeature {
847    /// Number of qubits
848    QubitCount,
849    /// Circuit depth
850    Depth,
851    /// Gate count
852    GateCount,
853    /// Gate type distribution
854    GateTypeDistribution,
855    /// Connectivity requirements
856    ConnectivityRequirements,
857    /// Parallelism potential
858    ParallelismPotential,
859}
860
861/// Hardware features
862#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
863pub enum HardwareFeature {
864    /// Available qubits
865    AvailableQubits,
866    /// Connectivity graph
867    ConnectivityGraph,
868    /// Error rates
869    ErrorRates,
870    /// Calibration quality
871    CalibrationQuality,
872    /// Queue status
873    QueueStatus,
874    /// Resource utilization
875    ResourceUtilization,
876}
877
878/// Performance features
879#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
880pub enum PerformanceFeature {
881    /// Execution time
882    ExecutionTime,
883    /// Throughput
884    Throughput,
885    /// Resource efficiency
886    ResourceEfficiency,
887    /// Quality metrics
888    QualityMetrics,
889    /// Cost metrics
890    CostMetrics,
891    /// Energy consumption
892    EnergyConsumption,
893}
894
895/// Feature normalization methods
896#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
897pub enum FeatureNormalization {
898    /// No normalization
899    None,
900    /// Min-max normalization
901    MinMax,
902    /// Z-score normalization
903    ZScore,
904    /// Robust normalization
905    Robust,
906    /// Unit vector normalization
907    UnitVector,
908}
909
910/// Load balancing configuration
911#[derive(Debug, Clone, Serialize, Deserialize)]
912pub struct LoadBalancingConfig {
913    /// Load balancing algorithm
914    pub algorithm: LoadBalancingAlgorithm,
915    /// Monitoring configuration
916    pub monitoring: LoadMonitoringConfig,
917    /// Rebalancing triggers
918    pub rebalancing_triggers: RebalancingTriggers,
919    /// Migration policies
920    pub migration_policies: MigrationPolicies,
921}
922
923/// Load balancing algorithms
924#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
925pub enum LoadBalancingAlgorithm {
926    /// Round-robin
927    RoundRobin,
928    /// Weighted round-robin
929    WeightedRoundRobin,
930    /// Least connections
931    LeastConnections,
932    /// Least response time
933    LeastResponseTime,
934    /// Resource-based balancing
935    ResourceBased,
936    /// Machine learning based
937    MachineLearningBased,
938}
939
940/// Load monitoring configuration
941#[derive(Debug, Clone, Serialize, Deserialize)]
942pub struct LoadMonitoringConfig {
943    /// Monitoring frequency
944    pub frequency: Duration,
945    /// Metrics to monitor
946    pub metrics: Vec<LoadMetric>,
947    /// Alerting thresholds
948    pub thresholds: LoadThresholds,
949    /// Historical data retention
950    pub retention_period: Duration,
951}
952
953/// Load metrics
954#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
955pub enum LoadMetric {
956    /// CPU utilization
957    CpuUtilization,
958    /// Memory utilization
959    MemoryUtilization,
960    /// QPU utilization
961    QpuUtilization,
962    /// Network utilization
963    NetworkUtilization,
964    /// Queue length
965    QueueLength,
966    /// Response time
967    ResponseTime,
968    /// Throughput
969    Throughput,
970    /// Error rate
971    ErrorRate,
972}
973
974/// Load thresholds
975#[derive(Debug, Clone, Serialize, Deserialize)]
976pub struct LoadThresholds {
977    /// CPU utilization threshold
978    pub cpu_threshold: f64,
979    /// Memory utilization threshold
980    pub memory_threshold: f64,
981    /// QPU utilization threshold
982    pub qpu_threshold: f64,
983    /// Network utilization threshold
984    pub network_threshold: f64,
985    /// Queue length threshold
986    pub queue_threshold: usize,
987    /// Response time threshold
988    pub response_time_threshold: Duration,
989}
990
991/// Rebalancing triggers
992#[derive(Debug, Clone, Serialize, Deserialize)]
993pub struct RebalancingTriggers {
994    /// CPU imbalance threshold
995    pub cpu_imbalance_threshold: f64,
996    /// Memory imbalance threshold
997    pub memory_imbalance_threshold: f64,
998    /// Queue imbalance threshold
999    pub queue_imbalance_threshold: f64,
1000    /// Time-based rebalancing interval
1001    pub time_interval: Option<Duration>,
1002    /// Event-based triggers
1003    pub event_triggers: Vec<RebalancingEvent>,
1004}
1005
1006/// Rebalancing events
1007#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1008pub enum RebalancingEvent {
1009    /// Node failure
1010    NodeFailure,
1011    /// Node recovery
1012    NodeRecovery,
1013    /// Capacity change
1014    CapacityChange,
1015    /// Load spike
1016    LoadSpike,
1017    /// Performance degradation
1018    PerformanceDegradation,
1019}
1020
1021/// Migration policies
1022#[derive(Debug, Clone, Serialize, Deserialize)]
1023pub struct MigrationPolicies {
1024    /// Migration cost threshold
1025    pub cost_threshold: f64,
1026    /// Maximum migrations per period
1027    pub max_migrations_per_period: usize,
1028    /// Migration period
1029    pub migration_period: Duration,
1030    /// Circuit migration strategy
1031    pub circuit_migration_strategy: CircuitMigrationStrategy,
1032    /// Data migration strategy
1033    pub data_migration_strategy: DataMigrationStrategy,
1034}
1035
1036/// Circuit migration strategies
1037#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1038pub enum CircuitMigrationStrategy {
1039    /// No migration
1040    None,
1041    /// Checkpoint and restart
1042    CheckpointRestart,
1043    /// Live migration
1044    LiveMigration,
1045    /// Incremental migration
1046    Incremental,
1047}
1048
1049/// Data migration strategies
1050#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1051pub enum DataMigrationStrategy {
1052    /// No data migration
1053    None,
1054    /// Copy-based migration
1055    Copy,
1056    /// Move-based migration
1057    Move,
1058    /// Distributed caching
1059    DistributedCaching,
1060}
1061
1062/// Resource monitoring configuration
1063#[derive(Debug, Clone, Serialize, Deserialize)]
1064pub struct ResourceMonitoringConfig {
1065    /// Enable real-time monitoring
1066    pub real_time_monitoring: bool,
1067    /// Monitoring granularity
1068    pub granularity: MonitoringGranularity,
1069    /// Metrics collection
1070    pub metrics_collection: MetricsCollectionConfig,
1071    /// Alerting configuration
1072    pub alerting: AlertingConfig,
1073    /// Reporting configuration
1074    pub reporting: ReportingConfig,
1075}
1076
1077/// Monitoring granularity
1078#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1079pub enum MonitoringGranularity {
1080    /// System-level monitoring
1081    System,
1082    /// Device-level monitoring
1083    Device,
1084    /// Circuit-level monitoring
1085    Circuit,
1086    /// Gate-level monitoring
1087    Gate,
1088    /// Operation-level monitoring
1089    Operation,
1090}
1091
1092/// Metrics collection configuration
1093#[derive(Debug, Clone, Serialize, Deserialize)]
1094pub struct MetricsCollectionConfig {
1095    /// Collection frequency
1096    pub frequency: Duration,
1097    /// Metrics to collect
1098    pub metrics: Vec<MonitoringMetric>,
1099    /// Data retention policy
1100    pub retention_policy: RetentionPolicy,
1101    /// Storage configuration
1102    pub storage_config: StorageConfig,
1103}
1104
1105/// Monitoring metrics
1106#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1107pub enum MonitoringMetric {
1108    /// Resource utilization
1109    ResourceUtilization,
1110    /// Performance metrics
1111    Performance,
1112    /// Quality metrics
1113    Quality,
1114    /// Cost metrics
1115    Cost,
1116    /// Energy metrics
1117    Energy,
1118    /// Availability metrics
1119    Availability,
1120    /// Security metrics
1121    Security,
1122}
1123
1124/// Data retention policy
1125#[derive(Debug, Clone, Serialize, Deserialize)]
1126pub struct RetentionPolicy {
1127    /// Raw data retention period
1128    pub raw_data_retention: Duration,
1129    /// Aggregated data retention period
1130    pub aggregated_data_retention: Duration,
1131    /// Archive policy
1132    pub archive_policy: ArchivePolicy,
1133    /// Compression settings
1134    pub compression: CompressionConfig,
1135}
1136
1137/// Archive policy
1138#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1139pub enum ArchivePolicy {
1140    /// No archiving
1141    None,
1142    /// Time-based archiving
1143    TimeBased(Duration),
1144    /// Size-based archiving
1145    SizeBased(usize),
1146    /// Custom archiving rules
1147    Custom(String),
1148}
1149
1150/// Storage configuration
1151#[derive(Debug, Clone, Serialize, Deserialize)]
1152pub struct StorageConfig {
1153    /// Storage backend
1154    pub backend: StorageBackend,
1155    /// Storage location
1156    pub location: String,
1157    /// Encryption settings
1158    pub encryption: EncryptionConfig,
1159    /// Replication settings
1160    pub replication: ReplicationConfig,
1161}
1162
1163/// Storage backends
1164#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1165pub enum StorageBackend {
1166    /// Local filesystem
1167    LocalFilesystem,
1168    /// Distributed filesystem
1169    DistributedFilesystem,
1170    /// Cloud storage
1171    CloudStorage,
1172    /// Database storage
1173    Database,
1174    /// Time-series database
1175    TimeSeriesDatabase,
1176}
1177
1178/// Encryption configuration
1179#[derive(Debug, Clone, Serialize, Deserialize)]
1180pub struct EncryptionConfig {
1181    /// Enable encryption
1182    pub enabled: bool,
1183    /// Encryption algorithm
1184    pub algorithm: EncryptionAlgorithm,
1185    /// Key management
1186    pub key_management: KeyManagementConfig,
1187}
1188
1189/// Encryption algorithms
1190#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1191pub enum EncryptionAlgorithm {
1192    /// AES-256
1193    AES256,
1194    /// ChaCha20-Poly1305
1195    ChaCha20Poly1305,
1196    /// XChaCha20-Poly1305
1197    XChaCha20Poly1305,
1198}
1199
1200/// Key management configuration
1201#[derive(Debug, Clone, Serialize, Deserialize)]
1202pub struct KeyManagementConfig {
1203    /// Key rotation frequency
1204    pub rotation_frequency: Duration,
1205    /// Key derivation function
1206    pub key_derivation: KeyDerivationFunction,
1207    /// Key storage backend
1208    pub storage_backend: KeyStorageBackend,
1209}
1210
1211/// Key derivation functions
1212#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1213pub enum KeyDerivationFunction {
1214    /// PBKDF2
1215    PBKDF2,
1216    /// Scrypt
1217    Scrypt,
1218    /// Argon2
1219    Argon2,
1220}
1221
1222/// Key storage backends
1223#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1224pub enum KeyStorageBackend {
1225    /// Local keystore
1226    Local,
1227    /// Hardware security module
1228    HSM,
1229    /// Cloud key management
1230    CloudKMS,
1231    /// Distributed keystore
1232    Distributed,
1233}
1234
1235/// Replication configuration
1236#[derive(Debug, Clone, Serialize, Deserialize)]
1237pub struct ReplicationConfig {
1238    /// Replication factor
1239    pub replication_factor: usize,
1240    /// Replication strategy
1241    pub strategy: ReplicationStrategy,
1242    /// Consistency level
1243    pub consistency_level: ConsistencyLevel,
1244}
1245
1246/// Replication strategies
1247#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1248pub enum ReplicationStrategy {
1249    /// Synchronous replication
1250    Synchronous,
1251    /// Asynchronous replication
1252    Asynchronous,
1253    /// Semi-synchronous replication
1254    SemiSynchronous,
1255    /// Multi-master replication
1256    MultiMaster,
1257}
1258
1259/// Consistency levels
1260#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1261pub enum ConsistencyLevel {
1262    /// Strong consistency
1263    Strong,
1264    /// Eventual consistency
1265    Eventual,
1266    /// Causal consistency
1267    Causal,
1268    /// Session consistency
1269    Session,
1270}
1271
1272/// Alerting configuration
1273#[derive(Debug, Clone, Serialize, Deserialize)]
1274pub struct AlertingConfig {
1275    /// Enable alerting
1276    pub enabled: bool,
1277    /// Alert rules
1278    pub rules: Vec<AlertRule>,
1279    /// Notification channels
1280    pub channels: Vec<NotificationChannel>,
1281    /// Alert aggregation
1282    pub aggregation: AlertAggregationConfig,
1283}
1284
1285/// Alert rule
1286#[derive(Debug, Clone, Serialize, Deserialize)]
1287pub struct AlertRule {
1288    /// Rule name
1289    pub name: String,
1290    /// Metric to monitor
1291    pub metric: MonitoringMetric,
1292    /// Threshold condition
1293    pub condition: ThresholdCondition,
1294    /// Alert severity
1295    pub severity: AlertSeverity,
1296    /// Evaluation frequency
1297    pub frequency: Duration,
1298}
1299
1300/// Threshold conditions
1301#[derive(Debug, Clone, Serialize, Deserialize)]
1302pub enum ThresholdCondition {
1303    /// Greater than threshold
1304    GreaterThan(f64),
1305    /// Less than threshold
1306    LessThan(f64),
1307    /// Equal to threshold
1308    EqualTo(f64),
1309    /// Within range
1310    WithinRange(f64, f64),
1311    /// Outside range
1312    OutsideRange(f64, f64),
1313}
1314
1315/// Alert severities
1316#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
1317pub enum AlertSeverity {
1318    /// Informational
1319    Info,
1320    /// Warning
1321    Warning,
1322    /// Error
1323    Error,
1324    /// Critical
1325    Critical,
1326}
1327
1328/// Notification channels
1329#[derive(Debug, Clone, Serialize, Deserialize)]
1330pub enum NotificationChannel {
1331    /// Email notification
1332    Email {
1333        recipients: Vec<String>,
1334        smtp_config: SmtpConfig,
1335    },
1336    /// Slack notification
1337    Slack {
1338        webhook_url: String,
1339        channel: String,
1340    },
1341    /// HTTP webhook
1342    Webhook {
1343        url: String,
1344        headers: HashMap<String, String>,
1345    },
1346    /// SMS notification
1347    SMS {
1348        phone_numbers: Vec<String>,
1349        provider_config: SmsProviderConfig,
1350    },
1351}
1352
1353/// SMTP configuration
1354#[derive(Debug, Clone, Serialize, Deserialize)]
1355pub struct SmtpConfig {
1356    /// SMTP server
1357    pub server: String,
1358    /// SMTP port
1359    pub port: u16,
1360    /// Username
1361    pub username: String,
1362    /// Use TLS
1363    pub use_tls: bool,
1364}
1365
1366/// SMS provider configuration
1367#[derive(Debug, Clone, Serialize, Deserialize)]
1368pub struct SmsProviderConfig {
1369    /// Provider name
1370    pub provider: String,
1371    /// API key
1372    pub api_key: String,
1373    /// API endpoint
1374    pub endpoint: String,
1375}
1376
1377/// Alert aggregation configuration
1378#[derive(Debug, Clone, Serialize, Deserialize)]
1379pub struct AlertAggregationConfig {
1380    /// Enable aggregation
1381    pub enabled: bool,
1382    /// Aggregation window
1383    pub window: Duration,
1384    /// Aggregation strategy
1385    pub strategy: AlertAggregationStrategy,
1386    /// Maximum alerts per window
1387    pub max_alerts_per_window: usize,
1388}
1389
1390/// Alert aggregation strategies
1391#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1392pub enum AlertAggregationStrategy {
1393    /// Count-based aggregation
1394    Count,
1395    /// Severity-based aggregation
1396    SeverityBased,
1397    /// Metric-based aggregation
1398    MetricBased,
1399    /// Time-based aggregation
1400    TimeBased,
1401}
1402
1403/// Reporting configuration
1404#[derive(Debug, Clone, Serialize, Deserialize)]
1405pub struct ReportingConfig {
1406    /// Enable automated reporting
1407    pub enabled: bool,
1408    /// Report types to generate
1409    pub report_types: Vec<ReportType>,
1410    /// Report frequency
1411    pub frequency: Duration,
1412    /// Report format
1413    pub format: ReportFormat,
1414    /// Report distribution
1415    pub distribution: ReportDistribution,
1416}
1417
1418/// Report types
1419#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1420pub enum ReportType {
1421    /// Performance report
1422    Performance,
1423    /// Resource utilization report
1424    ResourceUtilization,
1425    /// Quality metrics report
1426    QualityMetrics,
1427    /// Cost analysis report
1428    CostAnalysis,
1429    /// Capacity planning report
1430    CapacityPlanning,
1431    /// SLA compliance report
1432    SLACompliance,
1433}
1434
1435/// Report formats
1436#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1437pub enum ReportFormat {
1438    /// PDF format
1439    PDF,
1440    /// HTML format
1441    HTML,
1442    /// JSON format
1443    JSON,
1444    /// CSV format
1445    CSV,
1446    /// Excel format
1447    Excel,
1448}
1449
1450/// Report distribution
1451#[derive(Debug, Clone, Serialize, Deserialize)]
1452pub struct ReportDistribution {
1453    /// Email recipients
1454    pub email_recipients: Vec<String>,
1455    /// File system location
1456    pub file_location: Option<String>,
1457    /// Cloud storage location
1458    pub cloud_location: Option<String>,
1459    /// API endpoints
1460    pub api_endpoints: Vec<String>,
1461}
quantrs2_device/hardware_parallelization/config.rs

quantrs2_device/hardware_parallelization/
config.rs
