quantrs2_anneal/scientific_performance_optimization/
config.rs

1//! Configuration types for scientific performance optimization.
2//!
3//! This module contains all configuration structs and enums for the
4//! performance optimization system including memory, parallel processing,
5//! algorithm optimization, distributed computing, profiling, and GPU settings.
6
7use std::collections::HashMap;
8use std::time::Duration;
9
10/// Performance optimization configuration
11#[derive(Debug, Clone)]
12pub struct PerformanceOptimizationConfig {
13    /// Memory management settings
14    pub memory_config: MemoryOptimizationConfig,
15    /// Parallel processing configuration
16    pub parallel_config: ParallelProcessingConfig,
17    /// Algorithm optimization settings
18    pub algorithm_config: AlgorithmOptimizationConfig,
19    /// Distributed computing configuration
20    pub distributed_config: DistributedComputingConfig,
21    /// Profiling and monitoring settings
22    pub profiling_config: ProfilingConfig,
23    /// GPU acceleration settings
24    pub gpu_config: GPUAccelerationConfig,
25}
26
27impl Default for PerformanceOptimizationConfig {
28    fn default() -> Self {
29        Self {
30            memory_config: MemoryOptimizationConfig::default(),
31            parallel_config: ParallelProcessingConfig::default(),
32            algorithm_config: AlgorithmOptimizationConfig::default(),
33            distributed_config: DistributedComputingConfig::default(),
34            profiling_config: ProfilingConfig::default(),
35            gpu_config: GPUAccelerationConfig::default(),
36        }
37    }
38}
39
40/// Memory optimization configuration
41#[derive(Debug, Clone)]
42pub struct MemoryOptimizationConfig {
43    /// Enable hierarchical memory management
44    pub enable_hierarchical_memory: bool,
45    /// Cache size limits (in MB)
46    pub cache_size_limit: usize,
47    /// Memory pool configuration
48    pub memory_pool_config: MemoryPoolConfig,
49    /// Enable memory-mapped I/O
50    pub enable_memory_mapping: bool,
51    /// Compression settings
52    pub compression_config: CompressionConfig,
53    /// Garbage collection strategy
54    pub gc_strategy: GarbageCollectionStrategy,
55}
56
57impl Default for MemoryOptimizationConfig {
58    fn default() -> Self {
59        Self {
60            enable_hierarchical_memory: true,
61            cache_size_limit: 8192, // 8GB
62            memory_pool_config: MemoryPoolConfig::default(),
63            enable_memory_mapping: true,
64            compression_config: CompressionConfig::default(),
65            gc_strategy: GarbageCollectionStrategy::Adaptive,
66        }
67    }
68}
69
70/// Memory pool configuration
71#[derive(Debug, Clone)]
72pub struct MemoryPoolConfig {
73    /// Pool size in MB
74    pub pool_size: usize,
75    /// Block sizes for different allocations
76    pub block_sizes: Vec<usize>,
77    /// Enable pool preallocation
78    pub enable_preallocation: bool,
79    /// Pool growth strategy
80    pub growth_strategy: PoolGrowthStrategy,
81}
82
83impl Default for MemoryPoolConfig {
84    fn default() -> Self {
85        Self {
86            pool_size: 4096,                                // 4GB
87            block_sizes: vec![64, 256, 1024, 4096, 16_384], // Various block sizes
88            enable_preallocation: true,
89            growth_strategy: PoolGrowthStrategy::Exponential,
90        }
91    }
92}
93
94/// Pool growth strategies
95#[derive(Debug, Clone, PartialEq, Eq)]
96pub enum PoolGrowthStrategy {
97    /// Fixed size pools
98    Fixed,
99    /// Linear growth
100    Linear(usize),
101    /// Exponential growth
102    Exponential,
103    /// Adaptive growth based on usage patterns
104    Adaptive,
105}
106
107/// Compression configuration
108#[derive(Debug, Clone)]
109pub struct CompressionConfig {
110    /// Enable data compression
111    pub enable_compression: bool,
112    /// Compression algorithm
113    pub algorithm: CompressionAlgorithm,
114    /// Compression level (1-9)
115    pub compression_level: u8,
116    /// Threshold for compression (bytes)
117    pub compression_threshold: usize,
118}
119
120impl Default for CompressionConfig {
121    fn default() -> Self {
122        Self {
123            enable_compression: true,
124            algorithm: CompressionAlgorithm::LZ4,
125            compression_level: 6,
126            compression_threshold: 1024, // 1KB
127        }
128    }
129}
130
131/// Compression algorithms
132#[derive(Debug, Clone, PartialEq, Eq)]
133pub enum CompressionAlgorithm {
134    /// LZ4 - fast compression
135    LZ4,
136    /// ZSTD - balanced compression
137    ZSTD,
138    /// GZIP - high compression
139    GZIP,
140    /// Snappy - Google's compression
141    Snappy,
142}
143
144/// Garbage collection strategies
145#[derive(Debug, Clone, PartialEq, Eq)]
146pub enum GarbageCollectionStrategy {
147    /// Manual garbage collection
148    Manual,
149    /// Automatic GC based on memory pressure
150    Automatic,
151    /// Adaptive GC based on usage patterns
152    Adaptive,
153    /// Generational GC
154    Generational,
155}
156
157/// Parallel processing configuration
158#[derive(Debug, Clone)]
159pub struct ParallelProcessingConfig {
160    /// Number of worker threads
161    pub num_threads: usize,
162    /// Thread pool configuration
163    pub thread_pool_config: ThreadPoolConfig,
164    /// NUMA awareness settings
165    pub numa_config: NUMAConfig,
166    /// Task scheduling strategy
167    pub scheduling_strategy: TaskSchedulingStrategy,
168    /// Load balancing configuration
169    pub load_balancing: LoadBalancingConfig,
170}
171
172impl Default for ParallelProcessingConfig {
173    fn default() -> Self {
174        Self {
175            num_threads: num_cpus::get(),
176            thread_pool_config: ThreadPoolConfig::default(),
177            numa_config: NUMAConfig::default(),
178            scheduling_strategy: TaskSchedulingStrategy::WorkStealing,
179            load_balancing: LoadBalancingConfig::default(),
180        }
181    }
182}
183
184/// Thread pool configuration
185#[derive(Debug, Clone)]
186pub struct ThreadPoolConfig {
187    /// Core pool size
188    pub core_pool_size: usize,
189    /// Maximum pool size
190    pub max_pool_size: usize,
191    /// Thread keep-alive time
192    pub keep_alive_time: Duration,
193    /// Task queue size
194    pub queue_size: usize,
195    /// Thread priority
196    pub thread_priority: ThreadPriority,
197}
198
199impl Default for ThreadPoolConfig {
200    fn default() -> Self {
201        Self {
202            core_pool_size: num_cpus::get(),
203            max_pool_size: num_cpus::get() * 2,
204            keep_alive_time: Duration::from_secs(60),
205            queue_size: 10_000,
206            thread_priority: ThreadPriority::Normal,
207        }
208    }
209}
210
211/// Thread priorities
212#[derive(Debug, Clone, PartialEq, Eq)]
213pub enum ThreadPriority {
214    Low,
215    Normal,
216    High,
217    RealTime,
218}
219
220/// NUMA configuration
221#[derive(Debug, Clone)]
222pub struct NUMAConfig {
223    /// Enable NUMA awareness
224    pub enable_numa_awareness: bool,
225    /// Memory binding strategy
226    pub memory_binding: NUMAMemoryBinding,
227    /// Thread affinity settings
228    pub thread_affinity: NUMAThreadAffinity,
229}
230
231impl Default for NUMAConfig {
232    fn default() -> Self {
233        Self {
234            enable_numa_awareness: true,
235            memory_binding: NUMAMemoryBinding::LocalPreferred,
236            thread_affinity: NUMAThreadAffinity::Soft,
237        }
238    }
239}
240
241/// NUMA memory binding strategies
242#[derive(Debug, Clone, PartialEq, Eq)]
243pub enum NUMAMemoryBinding {
244    /// No binding
245    None,
246    /// Prefer local node
247    LocalPreferred,
248    /// Strict local binding
249    LocalStrict,
250    /// Interleaved across nodes
251    Interleaved,
252}
253
254/// NUMA thread affinity
255#[derive(Debug, Clone, PartialEq, Eq)]
256pub enum NUMAThreadAffinity {
257    /// No affinity
258    None,
259    /// Soft affinity (hint)
260    Soft,
261    /// Hard affinity (strict)
262    Hard,
263}
264
265/// Task scheduling strategies
266#[derive(Debug, Clone, PartialEq, Eq)]
267pub enum TaskSchedulingStrategy {
268    /// First-In-First-Out
269    FIFO,
270    /// Priority-based scheduling
271    Priority,
272    /// Work-stealing
273    WorkStealing,
274    /// Adaptive scheduling
275    Adaptive,
276}
277
278/// Load balancing configuration
279#[derive(Debug, Clone)]
280pub struct LoadBalancingConfig {
281    /// Enable dynamic load balancing
282    pub enable_dynamic_balancing: bool,
283    /// Load measurement interval
284    pub measurement_interval: Duration,
285    /// Rebalancing threshold
286    pub rebalancing_threshold: f64,
287    /// Balancing strategy
288    pub balancing_strategy: LoadBalancingStrategy,
289}
290
291impl Default for LoadBalancingConfig {
292    fn default() -> Self {
293        Self {
294            enable_dynamic_balancing: true,
295            measurement_interval: Duration::from_secs(5),
296            rebalancing_threshold: 0.2, // 20% imbalance
297            balancing_strategy: LoadBalancingStrategy::RoundRobin,
298        }
299    }
300}
301
302/// Load balancing strategies
303#[derive(Debug, Clone, PartialEq, Eq)]
304pub enum LoadBalancingStrategy {
305    /// Round-robin assignment
306    RoundRobin,
307    /// Least-loaded assignment
308    LeastLoaded,
309    /// Weighted assignment
310    Weighted,
311    /// Adaptive assignment
312    Adaptive,
313}
314
315/// Algorithm optimization configuration
316#[derive(Debug, Clone)]
317pub struct AlgorithmOptimizationConfig {
318    /// Enable algorithmic improvements
319    pub enable_algorithmic_improvements: bool,
320    /// Problem decomposition settings
321    pub decomposition_config: DecompositionConfig,
322    /// Caching and memoization settings
323    pub caching_config: CachingConfig,
324    /// Approximation algorithms settings
325    pub approximation_config: ApproximationConfig,
326    /// Streaming algorithms settings
327    pub streaming_config: StreamingConfig,
328}
329
330impl Default for AlgorithmOptimizationConfig {
331    fn default() -> Self {
332        Self {
333            enable_algorithmic_improvements: true,
334            decomposition_config: DecompositionConfig::default(),
335            caching_config: CachingConfig::default(),
336            approximation_config: ApproximationConfig::default(),
337            streaming_config: StreamingConfig::default(),
338        }
339    }
340}
341
342/// Problem decomposition configuration
343#[derive(Debug, Clone)]
344pub struct DecompositionConfig {
345    /// Enable hierarchical decomposition
346    pub enable_hierarchical_decomposition: bool,
347    /// Maximum subproblem size
348    pub max_subproblem_size: usize,
349    /// Decomposition strategy
350    pub decomposition_strategy: DecompositionStrategy,
351    /// Overlap strategy for subproblems
352    pub overlap_strategy: OverlapStrategy,
353}
354
355impl Default for DecompositionConfig {
356    fn default() -> Self {
357        Self {
358            enable_hierarchical_decomposition: true,
359            max_subproblem_size: 10_000,
360            decomposition_strategy: DecompositionStrategy::Adaptive,
361            overlap_strategy: OverlapStrategy::MinimalOverlap,
362        }
363    }
364}
365
366/// Decomposition strategies
367#[derive(Debug, Clone, PartialEq, Eq)]
368pub enum DecompositionStrategy {
369    /// Uniform decomposition
370    Uniform,
371    /// Adaptive decomposition
372    Adaptive,
373    /// Graph-based decomposition
374    GraphBased,
375    /// Hierarchical decomposition
376    Hierarchical,
377}
378
379/// Overlap strategies for subproblems
380#[derive(Debug, Clone, PartialEq, Eq)]
381pub enum OverlapStrategy {
382    /// No overlap
383    NoOverlap,
384    /// Minimal overlap
385    MinimalOverlap,
386    /// Substantial overlap
387    SubstantialOverlap,
388    /// Adaptive overlap
389    AdaptiveOverlap,
390}
391
392/// Caching and memoization configuration
393#[derive(Debug, Clone)]
394pub struct CachingConfig {
395    /// Enable result caching
396    pub enable_result_caching: bool,
397    /// Cache size limit (in MB)
398    pub cache_size_limit: usize,
399    /// Cache eviction policy
400    pub eviction_policy: CacheEvictionPolicy,
401    /// Cache compression
402    pub enable_cache_compression: bool,
403    /// Cache persistence
404    pub enable_cache_persistence: bool,
405}
406
407impl Default for CachingConfig {
408    fn default() -> Self {
409        Self {
410            enable_result_caching: true,
411            cache_size_limit: 2048, // 2GB
412            eviction_policy: CacheEvictionPolicy::LRU,
413            enable_cache_compression: true,
414            enable_cache_persistence: false,
415        }
416    }
417}
418
419/// Cache eviction policies
420#[derive(Debug, Clone, PartialEq, Eq)]
421pub enum CacheEvictionPolicy {
422    /// Least Recently Used
423    LRU,
424    /// Least Frequently Used
425    LFU,
426    /// First-In-First-Out
427    FIFO,
428    /// Adaptive Replacement Cache
429    ARC,
430}
431
432/// Approximation algorithms configuration
433#[derive(Debug, Clone)]
434pub struct ApproximationConfig {
435    /// Enable approximation algorithms
436    pub enable_approximations: bool,
437    /// Approximation quality threshold
438    pub quality_threshold: f64,
439    /// Maximum approximation error
440    pub max_approximation_error: f64,
441    /// Approximation strategies
442    pub approximation_strategies: Vec<ApproximationStrategy>,
443}
444
445impl Default for ApproximationConfig {
446    fn default() -> Self {
447        Self {
448            enable_approximations: true,
449            quality_threshold: 0.95,
450            max_approximation_error: 0.05,
451            approximation_strategies: vec![
452                ApproximationStrategy::Sampling,
453                ApproximationStrategy::Clustering,
454                ApproximationStrategy::DimensionalityReduction,
455            ],
456        }
457    }
458}
459
460/// Approximation strategies
461#[derive(Debug, Clone, PartialEq, Eq, Hash)]
462pub enum ApproximationStrategy {
463    /// Monte Carlo sampling
464    Sampling,
465    /// Clustering-based approximation
466    Clustering,
467    /// Dimensionality reduction
468    DimensionalityReduction,
469    /// Hierarchical approximation
470    Hierarchical,
471    /// Machine learning approximation
472    MachineLearning,
473}
474
475/// Streaming algorithms configuration
476#[derive(Debug, Clone)]
477pub struct StreamingConfig {
478    /// Enable streaming processing
479    pub enable_streaming: bool,
480    /// Buffer size for streaming
481    pub buffer_size: usize,
482    /// Streaming window size
483    pub window_size: usize,
484    /// Sliding window strategy
485    pub sliding_strategy: SlidingWindowStrategy,
486}
487
488impl Default for StreamingConfig {
489    fn default() -> Self {
490        Self {
491            enable_streaming: true,
492            buffer_size: 10_000,
493            window_size: 1000,
494            sliding_strategy: SlidingWindowStrategy::Tumbling,
495        }
496    }
497}
498
499/// Sliding window strategies
500#[derive(Debug, Clone, PartialEq, Eq)]
501pub enum SlidingWindowStrategy {
502    /// Tumbling windows
503    Tumbling,
504    /// Sliding windows
505    Sliding,
506    /// Session windows
507    Session,
508    /// Custom windows
509    Custom,
510}
511
512/// Distributed computing configuration
513#[derive(Debug, Clone)]
514pub struct DistributedComputingConfig {
515    /// Enable distributed processing
516    pub enable_distributed: bool,
517    /// Cluster configuration
518    pub cluster_config: ClusterConfig,
519    /// Communication protocol
520    pub communication_protocol: CommunicationProtocol,
521    /// Fault tolerance settings
522    pub fault_tolerance: DistributedFaultTolerance,
523}
524
525impl Default for DistributedComputingConfig {
526    fn default() -> Self {
527        Self {
528            enable_distributed: false,
529            cluster_config: ClusterConfig::default(),
530            communication_protocol: CommunicationProtocol::TCP,
531            fault_tolerance: DistributedFaultTolerance::default(),
532        }
533    }
534}
535
536/// Cluster configuration
537#[derive(Debug, Clone)]
538pub struct ClusterConfig {
539    /// Master node address
540    pub master_address: String,
541    /// Worker node addresses
542    pub worker_addresses: Vec<String>,
543    /// Node resources
544    pub node_resources: HashMap<String, NodeResources>,
545    /// Network topology
546    pub network_topology: NetworkTopology,
547}
548
549impl Default for ClusterConfig {
550    fn default() -> Self {
551        Self {
552            master_address: "localhost:8000".to_string(),
553            worker_addresses: vec![],
554            node_resources: HashMap::new(),
555            network_topology: NetworkTopology::StarTopology,
556        }
557    }
558}
559
560/// Node resource specification
561#[derive(Debug, Clone)]
562pub struct NodeResources {
563    /// CPU cores
564    pub cpu_cores: usize,
565    /// Memory in MB
566    pub memory_mb: usize,
567    /// GPU count
568    pub gpu_count: usize,
569    /// Network bandwidth (Mbps)
570    pub network_bandwidth: f64,
571}
572
573/// Network topologies
574#[derive(Debug, Clone, PartialEq, Eq)]
575pub enum NetworkTopology {
576    /// Star topology (master-worker)
577    StarTopology,
578    /// Ring topology
579    RingTopology,
580    /// Mesh topology
581    MeshTopology,
582    /// Tree topology
583    TreeTopology,
584}
585
586/// Communication protocols
587#[derive(Debug, Clone, PartialEq, Eq)]
588pub enum CommunicationProtocol {
589    /// TCP protocol
590    TCP,
591    /// UDP protocol
592    UDP,
593    /// MPI (Message Passing Interface)
594    MPI,
595    /// gRPC
596    GRPC,
597    /// Custom protocol
598    Custom(String),
599}
600
601/// Distributed fault tolerance
602#[derive(Debug, Clone)]
603pub struct DistributedFaultTolerance {
604    /// Enable automatic failover
605    pub enable_failover: bool,
606    /// Replication factor
607    pub replication_factor: usize,
608    /// Heartbeat interval
609    pub heartbeat_interval: Duration,
610    /// Recovery strategy
611    pub recovery_strategy: RecoveryStrategy,
612}
613
614impl Default for DistributedFaultTolerance {
615    fn default() -> Self {
616        Self {
617            enable_failover: true,
618            replication_factor: 2,
619            heartbeat_interval: Duration::from_secs(5),
620            recovery_strategy: RecoveryStrategy::Restart,
621        }
622    }
623}
624
625/// Recovery strategies
626#[derive(Debug, Clone, PartialEq, Eq)]
627pub enum RecoveryStrategy {
628    /// Restart failed tasks
629    Restart,
630    /// Migrate to other nodes
631    Migrate,
632    /// Checkpoint and restore
633    CheckpointRestore,
634    /// Adaptive recovery
635    Adaptive,
636}
637
638/// Profiling configuration
639#[derive(Debug, Clone)]
640pub struct ProfilingConfig {
641    /// Enable performance profiling
642    pub enable_profiling: bool,
643    /// Profiling granularity
644    pub profiling_granularity: ProfilingGranularity,
645    /// Metrics collection interval
646    pub collection_interval: Duration,
647    /// Enable memory profiling
648    pub enable_memory_profiling: bool,
649    /// Enable CPU profiling
650    pub enable_cpu_profiling: bool,
651    /// Enable I/O profiling
652    pub enable_io_profiling: bool,
653}
654
655impl Default for ProfilingConfig {
656    fn default() -> Self {
657        Self {
658            enable_profiling: true,
659            profiling_granularity: ProfilingGranularity::Function,
660            collection_interval: Duration::from_millis(100),
661            enable_memory_profiling: true,
662            enable_cpu_profiling: true,
663            enable_io_profiling: true,
664        }
665    }
666}
667
668/// Profiling granularity
669#[derive(Debug, Clone, PartialEq, Eq)]
670pub enum ProfilingGranularity {
671    /// Line-by-line profiling
672    Line,
673    /// Function-level profiling
674    Function,
675    /// Module-level profiling
676    Module,
677    /// Application-level profiling
678    Application,
679}
680
681/// GPU acceleration configuration
682#[derive(Debug, Clone)]
683pub struct GPUAccelerationConfig {
684    /// Enable GPU acceleration
685    pub enable_gpu: bool,
686    /// GPU device selection
687    pub device_selection: GPUDeviceSelection,
688    /// Memory management strategy
689    pub memory_strategy: GPUMemoryStrategy,
690    /// Kernel optimization settings
691    pub kernel_config: GPUKernelConfig,
692}
693
694impl Default for GPUAccelerationConfig {
695    fn default() -> Self {
696        Self {
697            enable_gpu: false, // Disabled by default
698            device_selection: GPUDeviceSelection::Automatic,
699            memory_strategy: GPUMemoryStrategy::Unified,
700            kernel_config: GPUKernelConfig::default(),
701        }
702    }
703}
704
705/// GPU device selection strategies
706#[derive(Debug, Clone, PartialEq, Eq)]
707pub enum GPUDeviceSelection {
708    /// Automatic device selection
709    Automatic,
710    /// Use specific device
711    Specific(usize),
712    /// Use multiple devices
713    Multiple(Vec<usize>),
714    /// Use all available devices
715    All,
716}
717
718/// GPU memory management strategies
719#[derive(Debug, Clone, PartialEq, Eq)]
720pub enum GPUMemoryStrategy {
721    /// Unified memory
722    Unified,
723    /// Explicit memory management
724    Explicit,
725    /// Streaming memory
726    Streaming,
727    /// Memory pooling
728    Pooled,
729}
730
731/// GPU kernel configuration
732#[derive(Debug, Clone)]
733pub struct GPUKernelConfig {
734    /// Block size for CUDA kernels
735    pub block_size: usize,
736    /// Grid size for CUDA kernels
737    pub grid_size: usize,
738    /// Enable kernel fusion
739    pub enable_kernel_fusion: bool,
740    /// Optimization level
741    pub optimization_level: GPUOptimizationLevel,
742}
743
744impl Default for GPUKernelConfig {
745    fn default() -> Self {
746        Self {
747            block_size: 256,
748            grid_size: 1024,
749            enable_kernel_fusion: true,
750            optimization_level: GPUOptimizationLevel::Aggressive,
751        }
752    }
753}
754
755/// GPU optimization levels
756#[derive(Debug, Clone, PartialEq, Eq)]
757pub enum GPUOptimizationLevel {
758    /// No optimization
759    None,
760    /// Basic optimization
761    Basic,
762    /// Aggressive optimization
763    Aggressive,
764    /// Maximum optimization
765    Maximum,
766}
quantrs2_anneal/scientific_performance_optimization/config.rs

quantrs2_anneal/scientific_performance_optimization/
config.rs
