quantrs2_tytan/realtime_quantum_integration/
queue.rs

1//! Queue management types for Real-time Quantum Computing Integration
2//!
3//! This module provides job queue management and load balancing types.
4
5use serde::{Deserialize, Serialize};
6use std::collections::{HashMap, VecDeque};
7use std::time::{Duration, SystemTime};
8
9use super::config::RealtimeConfig;
10use super::resource::ResourceCapacity;
11use super::types::{
12    ConnectivityType, DeviceType, FairnessPolicy, HealthCheckStatus, HealthCheckType, JobPriority,
13    JobStatus, LoadBalancingStrategy, PreemptionPolicy, SchedulingAlgorithm,
14};
15
16/// Queue management system
17pub struct QueueManager {
18    /// Job queues
19    pub(crate) job_queues: HashMap<JobPriority, VecDeque<QueuedJob>>,
20    /// Queue statistics
21    pub(crate) queue_stats: QueueStatistics,
22    /// Scheduling algorithm
23    pub(crate) scheduling_algorithm: SchedulingAlgorithm,
24    /// Queue policies
25    pub(crate) queue_policies: QueuePolicies,
26    /// Load balancer
27    pub(crate) load_balancer: LoadBalancer,
28}
29
30impl QueueManager {
31    pub fn new(_config: &RealtimeConfig) -> Self {
32        let mut job_queues = HashMap::new();
33        job_queues.insert(JobPriority::Critical, VecDeque::new());
34        job_queues.insert(JobPriority::High, VecDeque::new());
35        job_queues.insert(JobPriority::Normal, VecDeque::new());
36        job_queues.insert(JobPriority::Low, VecDeque::new());
37        job_queues.insert(JobPriority::Background, VecDeque::new());
38
39        Self {
40            job_queues,
41            queue_stats: QueueStatistics::default(),
42            scheduling_algorithm: SchedulingAlgorithm::PriorityBased,
43            queue_policies: QueuePolicies::default(),
44            load_balancer: LoadBalancer::new(),
45        }
46    }
47
48    pub fn submit_job(&mut self, job: QueuedJob) -> Result<String, String> {
49        let job_id = job.job_id.clone();
50        let priority = job.priority.clone();
51
52        if let Some(queue) = self.job_queues.get_mut(&priority) {
53            queue.push_back(job);
54            self.queue_stats.total_jobs_processed += 1;
55            Ok(job_id)
56        } else {
57            Err("Invalid job priority".to_string())
58        }
59    }
60}
61
62/// Job in the queue
63#[derive(Debug, Clone, Serialize, Deserialize)]
64pub struct QueuedJob {
65    /// Job ID
66    pub job_id: String,
67    /// Job type
68    pub job_type: JobType,
69    /// Priority
70    pub priority: JobPriority,
71    /// Resource requirements
72    pub resource_requirements: ResourceRequirements,
73    /// Submission time
74    pub submission_time: SystemTime,
75    /// Deadline
76    pub deadline: Option<SystemTime>,
77    /// Dependencies
78    pub dependencies: Vec<String>,
79    /// Job metadata
80    pub metadata: JobMetadata,
81    /// Current status
82    pub status: JobStatus,
83}
84
85/// Types of jobs
86#[derive(Debug, Clone, Serialize, Deserialize)]
87pub enum JobType {
88    QuantumCircuit,
89    Optimization,
90    Simulation,
91    Calibration,
92    Maintenance,
93    Hybrid,
94}
95
96/// Resource requirements for a job
97#[derive(Debug, Clone, Serialize, Deserialize)]
98pub struct ResourceRequirements {
99    /// Required qubits
100    pub qubits_required: Option<usize>,
101    /// Compute requirements
102    pub compute_requirements: ComputeRequirements,
103    /// Memory requirements
104    pub memory_requirements: MemoryRequirements,
105    /// Network requirements
106    pub network_requirements: Option<NetworkRequirements>,
107    /// Hardware constraints
108    pub hardware_constraints: Vec<HardwareConstraint>,
109}
110
111/// Compute requirements
112#[derive(Debug, Clone, Serialize, Deserialize)]
113pub struct ComputeRequirements {
114    /// CPU cores
115    pub cpu_cores: usize,
116    /// GPU units
117    pub gpu_units: Option<usize>,
118    /// Quantum processing units
119    pub qpu_units: Option<usize>,
120    /// Estimated runtime
121    pub estimated_runtime: Duration,
122}
123
124/// Memory requirements
125#[derive(Debug, Clone, Serialize, Deserialize)]
126pub struct MemoryRequirements {
127    /// RAM (in GB)
128    pub ram_gb: f64,
129    /// Storage (in GB)
130    pub storage_gb: f64,
131    /// Temporary storage (in GB)
132    pub temp_storage_gb: Option<f64>,
133}
134
135/// Network requirements
136#[derive(Debug, Clone, Serialize, Deserialize)]
137pub struct NetworkRequirements {
138    /// Bandwidth (in Mbps)
139    pub bandwidth_mbps: f64,
140    /// Latency tolerance
141    pub latency_tolerance: Duration,
142    /// Location preferences
143    pub location_preferences: Vec<String>,
144}
145
146/// Hardware constraints for job execution
147#[derive(Debug, Clone, Serialize, Deserialize)]
148pub enum HardwareConstraint {
149    SpecificDevice(String),
150    DeviceType(DeviceType),
151    MinimumFidelity(f64),
152    MaximumErrorRate(f64),
153    Connectivity(ConnectivityRequirement),
154}
155
156/// Connectivity requirements
157#[derive(Debug, Clone, Serialize, Deserialize)]
158pub enum ConnectivityRequirement {
159    AllToAll,
160    Linear,
161    Grid,
162    Custom(Vec<(usize, usize)>),
163}
164
165/// Job metadata
166#[derive(Debug, Clone, Serialize, Deserialize)]
167pub struct JobMetadata {
168    /// User ID
169    pub user_id: String,
170    /// Project ID
171    pub project_id: String,
172    /// Billing information
173    pub billing_info: BillingInfo,
174    /// Tags
175    pub tags: Vec<String>,
176    /// Experiment name
177    pub experiment_name: Option<String>,
178    /// Description
179    pub description: Option<String>,
180}
181
182/// Billing information for job tracking
183#[derive(Debug, Clone, Serialize, Deserialize)]
184pub struct BillingInfo {
185    /// Account ID
186    pub account_id: String,
187    /// Cost center
188    pub cost_center: Option<String>,
189    /// Budget limit
190    pub budget_limit: Option<f64>,
191    /// Cost estimate
192    pub cost_estimate: Option<f64>,
193}
194
195/// Queue statistics
196#[derive(Debug, Clone, Serialize, Deserialize)]
197pub struct QueueStatistics {
198    /// Total jobs processed
199    pub total_jobs_processed: usize,
200    /// Average wait time
201    pub average_wait_time: Duration,
202    /// Queue lengths
203    pub queue_lengths: HashMap<JobPriority, usize>,
204    /// Throughput metrics
205    pub throughput_metrics: ThroughputMetrics,
206    /// Resource utilization
207    pub resource_utilization: HashMap<String, f64>,
208}
209
210impl Default for QueueStatistics {
211    fn default() -> Self {
212        Self {
213            total_jobs_processed: 0,
214            average_wait_time: Duration::ZERO,
215            queue_lengths: HashMap::new(),
216            throughput_metrics: ThroughputMetrics {
217                jobs_per_hour: 0.0,
218                success_rate: 0.99,
219                average_execution_time: Duration::from_secs(300),
220                resource_efficiency: 0.85,
221            },
222            resource_utilization: HashMap::new(),
223        }
224    }
225}
226
227/// Throughput metrics
228#[derive(Debug, Clone, Serialize, Deserialize)]
229pub struct ThroughputMetrics {
230    /// Jobs per hour
231    pub jobs_per_hour: f64,
232    /// Success rate
233    pub success_rate: f64,
234    /// Average execution time
235    pub average_execution_time: Duration,
236    /// Resource efficiency
237    pub resource_efficiency: f64,
238}
239
240/// Queue policies
241#[derive(Debug, Clone, Serialize, Deserialize)]
242pub struct QueuePolicies {
243    /// Maximum queue length
244    pub max_queue_length: usize,
245    /// Job timeout
246    pub job_timeout: Duration,
247    /// Preemption policy
248    pub preemption_policy: PreemptionPolicy,
249    /// Fairness policy
250    pub fairness_policy: FairnessPolicy,
251    /// Resource limits
252    pub resource_limits: ResourceLimits,
253}
254
255impl Default for QueuePolicies {
256    fn default() -> Self {
257        Self {
258            max_queue_length: 1000,
259            job_timeout: Duration::from_secs(3600),
260            preemption_policy: PreemptionPolicy::PriorityBased,
261            fairness_policy: FairnessPolicy::WeightedFair,
262            resource_limits: ResourceLimits {
263                per_user_limits: HashMap::new(),
264                per_project_limits: HashMap::new(),
265                system_limits: ResourceCapacity {
266                    compute_units: 1000.0,
267                    memory_gb: 1024.0,
268                    storage_gb: 10000.0,
269                    network_mbps: 10000.0,
270                    custom_metrics: HashMap::new(),
271                },
272                time_based_limits: vec![],
273            },
274        }
275    }
276}
277
278/// Resource limits configuration
279#[derive(Debug, Clone, Serialize, Deserialize)]
280pub struct ResourceLimits {
281    /// Per-user limits
282    pub per_user_limits: HashMap<String, ResourceCapacity>,
283    /// Per-project limits
284    pub per_project_limits: HashMap<String, ResourceCapacity>,
285    /// System-wide limits
286    pub system_limits: ResourceCapacity,
287    /// Time-based limits
288    pub time_based_limits: Vec<TimeBoundLimit>,
289}
290
291/// Time-bound resource limit
292#[derive(Debug, Clone, Serialize, Deserialize)]
293pub struct TimeBoundLimit {
294    /// Time window
295    pub time_window: (SystemTime, SystemTime),
296    /// Resource limits during window
297    pub limits: ResourceCapacity,
298    /// Priority override
299    pub priority_override: Option<JobPriority>,
300}
301
302/// Load balancer
303#[derive(Debug, Clone)]
304pub struct LoadBalancer {
305    /// Load balancing strategy
306    pub(crate) strategy: LoadBalancingStrategy,
307    /// Server weights
308    pub(crate) server_weights: HashMap<String, f64>,
309    /// Health checks
310    pub(crate) health_checks: HashMap<String, HealthCheck>,
311    /// Load metrics
312    pub(crate) load_metrics: HashMap<String, LoadMetrics>,
313}
314
315impl Default for LoadBalancer {
316    fn default() -> Self {
317        Self::new()
318    }
319}
320
321impl LoadBalancer {
322    pub fn new() -> Self {
323        Self {
324            strategy: LoadBalancingStrategy::RoundRobin,
325            server_weights: HashMap::new(),
326            health_checks: HashMap::new(),
327            load_metrics: HashMap::new(),
328        }
329    }
330}
331
332/// Health check configuration
333#[derive(Debug, Clone)]
334pub struct HealthCheck {
335    /// Check type
336    pub check_type: HealthCheckType,
337    /// Interval
338    pub interval: Duration,
339    /// Timeout
340    pub timeout: Duration,
341    /// Last check time
342    pub last_check: SystemTime,
343    /// Status
344    pub status: HealthCheckStatus,
345}
346
347/// Load metrics for a server
348#[derive(Debug, Clone, Serialize, Deserialize)]
349pub struct LoadMetrics {
350    /// Current load
351    pub current_load: f64,
352    /// Response time
353    pub response_time: Duration,
354    /// Error rate
355    pub error_rate: f64,
356    /// Throughput
357    pub throughput: f64,
358    /// Capacity utilization
359    pub capacity_utilization: f64,
360}
quantrs2_tytan/realtime_quantum_integration/queue.rs

quantrs2_tytan/realtime_quantum_integration/
queue.rs
