quantrs2_device/hardware_parallelization/
types.rs

1//! Supporting types for hardware parallelization
2
3use super::config::*;
4use super::monitor::{
5    ExecutionQualityMetrics, OptimizationSuggestion, PerformanceMetrics, ResourceUsage,
6};
7use crate::translation::HardwareBackend;
8use quantrs2_core::qubit::QubitId;
9use serde::{Deserialize, Serialize};
10use std::collections::{HashMap, VecDeque};
11use std::time::{Duration, SystemTime};
12
13/// Parallel circuit execution task
14#[derive(Debug)]
15pub struct ParallelCircuitTask {
16    pub id: String,
17    pub circuit: Box<dyn std::any::Any + Send + Sync>,
18    pub target_backend: HardwareBackend,
19    pub priority: TaskPriority,
20    pub resource_requirements: ParallelResourceRequirements,
21    pub constraints: ExecutionConstraints,
22    pub submitted_at: SystemTime,
23    pub deadline: Option<SystemTime>,
24}
25
26/// Parallel gate execution task
27#[derive(Debug, Clone)]
28pub struct ParallelGateTask {
29    pub id: String,
30    pub gate_operations: Vec<ParallelGateOperation>,
31    pub target_qubits: Vec<QubitId>,
32    pub dependency_graph: HashMap<String, Vec<String>>,
33    pub priority: TaskPriority,
34    pub submitted_at: SystemTime,
35}
36
37/// Task priorities
38#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
39pub enum TaskPriority {
40    /// Low priority (best effort)
41    Low,
42    /// Normal priority
43    Normal,
44    /// High priority
45    High,
46    /// Critical priority (real-time)
47    Critical,
48    /// System priority (internal operations)
49    System,
50}
51
52/// Parallel resource requirements
53#[derive(Debug, Clone, Serialize, Deserialize)]
54pub struct ParallelResourceRequirements {
55    /// Required CPU cores
56    pub required_cpu_cores: usize,
57    /// Required memory (MB)
58    pub required_memory_mb: f64,
59    /// Required QPU time
60    pub required_qpu_time: Duration,
61    /// Required network bandwidth (Mbps)
62    pub required_bandwidth_mbps: f64,
63    /// Required storage (MB)
64    pub required_storage_mb: f64,
65}
66
67/// Execution constraints
68#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct ExecutionConstraints {
70    /// Allowed backends
71    pub allowed_backends: Vec<HardwareBackend>,
72    /// Forbidden backends
73    pub forbidden_backends: Vec<HardwareBackend>,
74    /// Quality requirements
75    pub quality_requirements: QualityRequirements,
76    /// Timing constraints
77    pub timing_constraints: TimingConstraints,
78    /// Resource constraints
79    pub resource_constraints: ResourceConstraints,
80}
81
82/// Quality requirements
83#[derive(Debug, Clone, Serialize, Deserialize)]
84pub struct QualityRequirements {
85    /// Minimum fidelity
86    pub min_fidelity: Option<f64>,
87    /// Maximum error rate
88    pub max_error_rate: Option<f64>,
89    /// Required calibration recency
90    pub calibration_recency: Option<Duration>,
91    /// Quality assessment method
92    pub assessment_method: QualityAssessmentMethod,
93}
94
95/// Quality assessment methods
96#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
97pub enum QualityAssessmentMethod {
98    /// Static quality metrics
99    Static,
100    /// Dynamic quality monitoring
101    Dynamic,
102    /// Predictive quality modeling
103    Predictive,
104    /// Benchmarking-based assessment
105    BenchmarkBased,
106}
107
108/// Timing constraints
109#[derive(Debug, Clone, Serialize, Deserialize)]
110pub struct TimingConstraints {
111    /// Maximum execution time
112    pub max_execution_time: Option<Duration>,
113    /// Maximum queue wait time
114    pub max_queue_time: Option<Duration>,
115    /// Preferred execution window
116    pub preferred_window: Option<(SystemTime, SystemTime)>,
117    /// Scheduling flexibility
118    pub scheduling_flexibility: SchedulingFlexibility,
119}
120
121/// Scheduling flexibility levels
122#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
123pub enum SchedulingFlexibility {
124    /// Rigid scheduling (exact timing required)
125    Rigid,
126    /// Flexible scheduling (best effort)
127    Flexible,
128    /// Adaptive scheduling (can adjust based on conditions)
129    Adaptive,
130}
131
132/// Resource constraints
133#[derive(Debug, Clone, Serialize, Deserialize)]
134pub struct ResourceConstraints {
135    /// Maximum cost
136    pub max_cost: Option<f64>,
137    /// Maximum energy consumption
138    pub max_energy: Option<f64>,
139    /// Resource usage limits
140    pub usage_limits: HashMap<String, f64>,
141    /// Sharing preferences
142    pub sharing_preferences: SharingPreferences,
143}
144
145/// Sharing preferences
146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
147pub enum SharingPreferences {
148    /// Exclusive resource access
149    Exclusive,
150    /// Shared resource access
151    Shared,
152    /// Best effort sharing
153    BestEffort,
154    /// Conditional sharing
155    Conditional(Vec<SharingCondition>),
156}
157
158/// Sharing conditions
159#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
160pub enum SharingCondition {
161    /// Share only with specific users
162    UserWhitelist(Vec<String>),
163    /// Share only with specific circuit types
164    CircuitTypeWhitelist(Vec<String>),
165    /// Share only during specific time windows
166    TimeWindow(SystemTime, SystemTime),
167    /// Share only below resource threshold
168    ResourceThreshold(String, f64),
169}
170
171/// Parallel gate operation
172#[derive(Debug, Clone, Serialize, Deserialize)]
173pub struct ParallelGateOperation {
174    /// Operation ID
175    pub id: String,
176    /// Gate type
177    pub gate_type: String,
178    /// Target qubits
179    pub qubits: Vec<QubitId>,
180    /// Gate parameters
181    pub parameters: Vec<f64>,
182    /// Dependencies on other operations
183    pub dependencies: Vec<String>,
184    /// Parallelization hints
185    pub parallelization_hints: ParallelizationHints,
186}
187
188/// Parallelization hints
189#[derive(Debug, Clone, Serialize, Deserialize)]
190pub struct ParallelizationHints {
191    /// Can be executed in parallel with others
192    pub parallel_safe: bool,
193    /// Preferred execution order
194    pub execution_order: Option<usize>,
195    /// Resource affinity
196    pub resource_affinity: ResourceAffinity,
197    /// Scheduling hints
198    pub scheduling_hints: SchedulingHints,
199}
200
201/// Resource affinity
202#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
203pub enum ResourceAffinity {
204    /// No preference
205    None,
206    /// Prefer specific backend
207    Backend(HardwareBackend),
208    /// Prefer specific qubits
209    Qubits(Vec<QubitId>),
210    /// Prefer co-location with other operations
211    CoLocation(Vec<String>),
212}
213
214/// Scheduling hints
215#[derive(Debug, Clone, Serialize, Deserialize)]
216pub struct SchedulingHints {
217    /// Preferred execution time
218    pub preferred_time: Option<SystemTime>,
219    /// Execution priority
220    pub priority: TaskPriority,
221    /// Deadline
222    pub deadline: Option<SystemTime>,
223    /// Batch compatibility
224    pub batch_compatible: bool,
225}
226
227/// Resource monitor for tracking system resources
228
229/// Load metrics for a backend
230#[derive(Debug, Clone, Serialize, Deserialize)]
231pub struct LoadMetrics {
232    pub cpu_load: f64,
233    pub memory_load: f64,
234    pub qpu_load: f64,
235    pub network_load: f64,
236    pub queue_length: usize,
237    pub response_time: Duration,
238    pub throughput: f64,
239    pub error_rate: f64,
240    pub last_updated: SystemTime,
241}
242
243/// Load snapshot for historical tracking
244#[derive(Debug, Clone, Serialize, Deserialize)]
245pub struct LoadSnapshot {
246    pub timestamp: SystemTime,
247    pub backend_loads: HashMap<HardwareBackend, LoadMetrics>,
248    pub system_metrics: SystemMetrics,
249    pub predictions: LoadPredictions,
250}
251
252/// System-wide metrics
253#[derive(Debug, Clone, Serialize, Deserialize)]
254pub struct SystemMetrics {
255    pub total_throughput: f64,
256    pub average_latency: Duration,
257    pub total_resource_utilization: f64,
258    pub overall_quality_score: f64,
259    pub cost_per_operation: f64,
260    pub energy_per_operation: f64,
261}
262
263/// Load predictions
264#[derive(Debug, Clone, Serialize, Deserialize)]
265pub struct LoadPredictions {
266    pub predicted_loads: HashMap<HardwareBackend, f64>,
267    pub confidence_levels: HashMap<HardwareBackend, f64>,
268    pub prediction_horizon: Duration,
269    pub model_accuracy: f64,
270}
271
272/// Rebalancing strategy
273#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
274pub enum RebalancingStrategy {
275    /// Reactive rebalancing
276    Reactive,
277    /// Proactive rebalancing
278    Proactive,
279    /// Predictive rebalancing
280    Predictive,
281    /// Hybrid approach
282    Hybrid,
283}
284
285/// Migration tracker
286pub struct MigrationTracker {
287    pub active_migrations: HashMap<String, MigrationStatus>,
288    pub migration_history: VecDeque<MigrationRecord>,
289    pub migration_costs: HashMap<(HardwareBackend, HardwareBackend), f64>,
290}
291
292/// Migration status
293#[derive(Debug, Clone, Serialize, Deserialize)]
294pub struct MigrationStatus {
295    pub task_id: String,
296    pub source_backend: HardwareBackend,
297    pub target_backend: HardwareBackend,
298    pub progress: f64, // 0.0 to 1.0
299    pub started_at: SystemTime,
300    pub estimated_completion: SystemTime,
301    pub migration_type: MigrationType,
302}
303
304/// Migration types
305#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
306pub enum MigrationType {
307    /// Circuit migration
308    Circuit,
309    /// Data migration
310    Data,
311    /// State migration
312    State,
313    /// Full migration
314    Full,
315}
316
317/// Migration record for tracking history
318#[derive(Debug, Clone, Serialize, Deserialize)]
319pub struct MigrationRecord {
320    pub task_id: String,
321    pub source_backend: HardwareBackend,
322    pub target_backend: HardwareBackend,
323    pub migration_time: Duration,
324    pub success: bool,
325    pub cost: f64,
326    pub quality_impact: f64,
327    pub timestamp: SystemTime,
328}
329
330/// Parallel execution result
331#[derive(Debug, Clone, Serialize, Deserialize)]
332pub struct ParallelExecutionResult {
333    pub task_id: String,
334    pub success: bool,
335    pub execution_time: Duration,
336    pub resource_usage: ResourceUsage,
337    pub quality_metrics: ExecutionQualityMetrics,
338    pub results: Option<Vec<u8>>, // Serialized results
339    pub error_message: Option<String>,
340}
341
342/// Load balancing result
343#[derive(Debug, Clone, Serialize, Deserialize)]
344pub struct LoadBalancingResult {
345    pub rebalancing_performed: bool,
346    pub migrations_performed: usize,
347    pub load_improvement: f64,
348    pub estimated_performance_gain: f64,
349    pub rebalancing_cost: f64,
350}
quantrs2_device/hardware_parallelization/types.rs

quantrs2_device/hardware_parallelization/
types.rs
