quantrs2_device/distributed/
types.rs

1//! Common types and data structures for distributed orchestration
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::net::SocketAddr;
6use std::sync::{Arc, Mutex};
7use std::time::{Duration, Instant, SystemTime};
8
9use super::config::DistributedOrchestratorConfig;
10
11// Main orchestrator type
12//
13// Holds the real, locally-computable state needed for node registration and
14// workflow scheduling: a node registry, a workflow registry, and a monotonic
15// execution-id counter. Actual network dispatch to remote nodes is not
16// implemented (it requires a real inter-node transport), so
17// `execute_distributed` reports that limitation honestly instead of
18// fabricating a successful result.
19#[derive(Debug)]
20pub struct DistributedQuantumOrchestrator {
21    pub(crate) config: DistributedOrchestratorConfig,
22    pub(crate) nodes: Arc<Mutex<HashMap<String, NodeInfo>>>,
23    pub(crate) workflows: Arc<Mutex<HashMap<String, DistributedWorkflow>>>,
24    pub(crate) execution_counter: Arc<Mutex<u64>>,
25}
26
27// Core execution types
28#[derive(Debug, Clone, Serialize, Deserialize)]
29pub struct DistributedExecutionResult {
30    pub execution_id: String,
31    pub status: DistributedExecutionStatus,
32    pub results: HashMap<String, String>,
33    pub performance_metrics: DistributedPerformanceAnalytics,
34    pub execution_time: Duration,
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
38pub enum DistributedExecutionStatus {
39    Pending,
40    Running,
41    Completed,
42    Failed,
43    Cancelled,
44}
45
46// Node information
47#[derive(Debug, Clone, Serialize, Deserialize)]
48pub struct NodeInfo {
49    pub node_id: String,
50    pub address: SocketAddr,
51    pub capabilities: NodeCapabilities,
52    pub status: NodeStatus,
53    #[serde(skip)]
54    pub last_heartbeat: Option<Instant>,
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
58pub struct NodeCapabilities {
59    pub max_qubits: u32,
60    pub supported_gates: Vec<String>,
61    pub connectivity: HashMap<u32, Vec<u32>>,
62    pub error_rates: HashMap<String, f64>,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
66pub enum NodeStatus {
67    Available,
68    Busy,
69    Offline,
70    Maintenance,
71    Error,
72}
73
74// Workflow types
75#[derive(Debug, Clone, Serialize, Deserialize)]
76pub struct DistributedWorkflow {
77    pub workflow_id: String,
78    pub workflow_type: DistributedWorkflowType,
79    pub steps: Vec<String>,
80    pub dependencies: HashMap<String, Vec<String>>,
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize)]
84pub enum DistributedWorkflowType {
85    Sequential,
86    Parallel,
87    ConditionalBranching,
88    IterativeLoop,
89    EventDriven,
90}
91
92// Event and command types
93#[derive(Debug, Clone, Serialize, Deserialize)]
94pub struct DistributedEvent {
95    pub event_id: String,
96    pub event_type: String,
97    pub timestamp: SystemTime,
98    pub data: HashMap<String, String>,
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
102pub struct DistributedCommand {
103    pub command_id: String,
104    pub command_type: String,
105    pub target_node: String,
106    pub parameters: HashMap<String, String>,
107}
108
109// Circuit decomposition
110#[derive(Debug, Clone, Serialize, Deserialize)]
111pub struct CircuitDecompositionResult {
112    pub subcircuits: Vec<String>,
113    pub dependencies: HashMap<String, Vec<String>>,
114    pub resource_requirements: HashMap<String, u32>,
115}
116
117// Default implementations
118impl Default for DistributedExecutionResult {
119    fn default() -> Self {
120        Self {
121            execution_id: "default".to_string(),
122            status: DistributedExecutionStatus::Pending,
123            results: HashMap::new(),
124            performance_metrics: DistributedPerformanceAnalytics::default(),
125            execution_time: Duration::from_secs(0),
126        }
127    }
128}
129
130impl Default for NodeCapabilities {
131    fn default() -> Self {
132        Self {
133            max_qubits: 5,
134            supported_gates: vec![
135                "X".to_string(),
136                "Y".to_string(),
137                "Z".to_string(),
138                "CNOT".to_string(),
139            ],
140            connectivity: HashMap::new(),
141            error_rates: HashMap::new(),
142        }
143    }
144}
145
146// Placeholder for analytics type
147#[derive(Debug, Clone, Serialize, Deserialize, Default)]
148pub struct DistributedPerformanceAnalytics {
149    pub throughput: f64,
150    pub latency: Duration,
151    pub error_rate: f64,
152    pub resource_utilization: f64,
153}
quantrs2_device/distributed/types.rs

quantrs2_device/distributed/
types.rs
