Struct DistributedExecutor 

pub struct DistributedExecutor {
    pub backends: Vec<ExecutionBackend>,
    pub load_balancer: LoadBalancer,
    pub fault_tolerance: FaultToleranceConfig,
    pub scheduler: ExecutionScheduler,
    pub resource_manager: ResourceManager,
}

A distributed quantum circuit execution engine

This manages execution of quantum circuits across multiple backends, handling load balancing, fault tolerance, and result aggregation.

Fields

backends: Vec<ExecutionBackend>

Available execution backends

load_balancer: LoadBalancer

Load balancing strategy

fault_tolerance: FaultToleranceConfig

Fault tolerance configuration

scheduler: ExecutionScheduler

Execution scheduling policy

resource_manager: ResourceManager

Resource management

Implementations

impl DistributedExecutor

pub fn new() -> Self

Create a new distributed executor

Examples found in repository

examples/distributed_demo.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 Distributed Circuit Execution Demo");
    println!("====================================\n");

    // Example 1: Setting up a distributed executor
    println!("1. Creating Distributed Executor");
    println!("--------------------------------");

    let mut executor = DistributedExecutor::new();
    println!("Created distributed executor with default configuration");
    println!("  Load balancing: {:?}", executor.load_balancer.strategy);
    println!("  Scheduling policy: {:?}", executor.scheduler.policy);
    println!(
        "  Fault tolerance enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );

    // Example 2: Adding different types of backends
    println!("\n2. Adding Execution Backends");
    println!("----------------------------");

    // Add a quantum hardware backend
    let hardware_backend = create_hardware_backend();
    println!("Adding hardware backend: {}", hardware_backend.id);
    executor.add_backend(hardware_backend)?;

    // Add a simulator backend
    let simulator_backend = create_simulator_backend();
    println!("Adding simulator backend: {}", simulator_backend.id);
    executor.add_backend(simulator_backend)?;

    // Add a cloud service backend
    let cloud_backend = create_cloud_backend();
    println!("Adding cloud backend: {}", cloud_backend.id);
    executor.add_backend(cloud_backend)?;

    // Add a hybrid backend
    let hybrid_backend = create_hybrid_backend();
    println!("Adding hybrid backend: {}", hybrid_backend.id);
    executor.add_backend(hybrid_backend)?;

    println!("Total backends added: {}", executor.backends.len());

    // Example 3: System health status
    println!("\n3. System Health Status");
    println!("-----------------------");

    let health = executor.get_health_status();
    println!("System health:");
    println!("  Total backends: {}", health.total_backends);
    println!("  Available backends: {}", health.available_backends);
    println!("  Total qubits: {}", health.total_qubits);
    println!(
        "  Average queue time: {:.2} seconds",
        health.average_queue_time
    );
    println!("  System load: {:.1}%", health.system_load * 100.0);

    // Example 4: Creating and submitting jobs
    println!("\n4. Creating and Submitting Jobs");
    println!("-------------------------------");

    // Create different types of circuits for testing
    let jobs = create_test_jobs();

    for (i, job) in jobs.iter().enumerate() {
        println!(
            "Job {}: {} ({} qubits, {} gates, priority: {:?})",
            i + 1,
            job.id,
            job.circuit.num_qubits(),
            job.circuit.num_gates(),
            job.priority
        );

        match executor.submit_job(job.clone()) {
            Ok(job_id) => println!("  ✅ Submitted successfully: {}", job_id),
            Err(e) => println!("  ❌ Submission failed: {}", e),
        }
    }

    // Example 5: Different load balancing strategies
    println!("\n5. Load Balancing Strategies");
    println!("----------------------------");

    let strategies = vec![
        ("Round Robin", LoadBalancingStrategy::RoundRobin),
        ("Least Connections", LoadBalancingStrategy::LeastConnections),
        ("Least Queue Time", LoadBalancingStrategy::LeastQueueTime),
        ("Best Performance", LoadBalancingStrategy::BestPerformance),
    ];

    for (name, strategy) in strategies {
        executor.load_balancer.strategy = strategy.clone();
        println!("  {}: {:?}", name, strategy);
    }

    // Example 6: Backend types and capabilities
    println!("\n6. Backend Types and Capabilities");
    println!("---------------------------------");

    for backend in &executor.backends {
        println!("Backend: {} ({:?})", backend.id, backend.status);
        match &backend.backend_type {
            BackendType::Hardware {
                vendor,
                model,
                location,
            } => {
                println!("  Type: Hardware ({} {} in {})", vendor, model, location);
            }
            BackendType::Simulator {
                simulator_type,
                host,
            } => {
                println!("  Type: Simulator ({:?} on {})", simulator_type, host);
            }
            BackendType::CloudService {
                provider,
                service_name,
                region,
            } => {
                println!(
                    "  Type: Cloud ({} {} in {})",
                    provider, service_name, region
                );
            }
            BackendType::Hybrid {
                quantum_backend: _,
                classical_resources,
            } => {
                println!(
                    "  Type: Hybrid ({} CPU cores, {:.1} GB memory)",
                    classical_resources.cpu_cores, classical_resources.memory_gb
                );
            }
        }

        println!("  Capabilities:");
        println!("    Max qubits: {}", backend.performance.max_qubits);
        println!("    Max depth: {}", backend.performance.max_depth);
        println!(
            "    Supported gates: {:?}",
            backend.capabilities.supported_gates
        );
        println!(
            "    Mid-circuit measurements: {}",
            backend.capabilities.mid_circuit_measurements
        );
        println!(
            "    Queue length: {}/{}",
            backend.queue_info.queue_length, backend.queue_info.max_queue_size
        );
        println!(
            "    Estimated wait time: {:.1} seconds",
            backend.queue_info.estimated_wait_time
        );
        println!();
    }

    // Example 7: Execution parameters and error mitigation
    println!("7. Execution Parameters and Error Mitigation");
    println!("--------------------------------------------");

    let error_mitigation_techniques = vec![
        (
            "Readout Error Mitigation",
            ErrorMitigation::ReadoutErrorMitigation,
        ),
        (
            "Zero Noise Extrapolation",
            ErrorMitigation::ZeroNoiseExtrapolation,
        ),
        (
            "Clifford Data Regression",
            ErrorMitigation::CliffordDataRegression,
        ),
        (
            "Symmetry Verification",
            ErrorMitigation::SymmetryVerification,
        ),
    ];

    for (name, technique) in error_mitigation_techniques {
        println!("  {}: {:?}", name, technique);
    }

    let result_formats = vec![
        ("Counts", ResultFormat::Counts),
        ("Probabilities", ResultFormat::Probabilities),
        ("Statevector", ResultFormat::Statevector),
        ("Expectation Values", ResultFormat::ExpectationValues),
    ];

    println!("\nResult formats:");
    for (name, format) in result_formats {
        println!("  {}: {:?}", name, format);
    }

    // Example 8: Fault tolerance and redundancy
    println!("\n8. Fault Tolerance and Redundancy");
    println!("---------------------------------");

    println!("Current fault tolerance configuration:");
    println!(
        "  Failover enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );
    println!(
        "  Error correction: {:?}",
        executor.fault_tolerance.error_correction
    );

    // Demonstrate different error correction strategies
    let error_correction_strategies = vec![
        ("None", ErrorCorrectionStrategy::None),
        ("Majority Voting", ErrorCorrectionStrategy::MajorityVoting),
        (
            "Quantum Error Correction",
            ErrorCorrectionStrategy::QuantumErrorCorrection,
        ),
        (
            "Classical Post-processing",
            ErrorCorrectionStrategy::ClassicalPostProcessing,
        ),
    ];

    println!("\nAvailable error correction strategies:");
    for (name, strategy) in error_correction_strategies {
        println!("  {}: {:?}", name, strategy);
    }

    // Example 9: Resource management and allocation
    println!("\n9. Resource Management and Allocation");
    println!("------------------------------------");

    println!("Resource pool:");
    println!(
        "  Total qubits: {}",
        executor.resource_manager.resource_pool.total_qubits
    );
    println!(
        "  Available slots: {}",
        executor.resource_manager.resource_pool.available_slots
    );
    println!(
        "  Memory pool: {:.1} GB",
        executor.resource_manager.resource_pool.memory_pool
    );
    println!(
        "  Compute pool: {:.1} CPU hours",
        executor.resource_manager.resource_pool.compute_pool
    );

    println!("\nAllocation policies:");
    if let Some(max_qubits) = executor
        .resource_manager
        .allocation_policies
        .max_qubits_per_user
    {
        println!("  Max qubits per user: {}", max_qubits);
    }
    if let Some(max_time) = executor
        .resource_manager
        .allocation_policies
        .max_execution_time
    {
        println!("  Max execution time: {:.1} seconds", max_time);
    }
    println!(
        "  Fair share: {}",
        executor.resource_manager.allocation_policies.fair_share
    );
    println!(
        "  Reserved resources: {:.1}%",
        executor
            .resource_manager
            .allocation_policies
            .reserved_resources
            * 100.0
    );

    // Example 10: Network configuration and authentication
    println!("\n10. Network Configuration and Authentication");
    println!("-------------------------------------------");

    for backend in &executor.backends {
        println!(
            "Backend {}: {}",
            backend.id, backend.network_config.endpoint
        );
        println!(
            "  Auth type: {:?}",
            backend.network_config.credentials.auth_type
        );
        println!(
            "  Connection timeout: {:.1}s",
            backend.network_config.timeouts.connection_timeout
        );
        println!(
            "  Request timeout: {:.1}s",
            backend.network_config.timeouts.request_timeout
        );
        println!(
            "  Max retries: {}",
            backend.network_config.retry_policy.max_retries
        );
        println!(
            "  Backoff strategy: {:?}",
            backend.network_config.retry_policy.backoff_strategy
        );
    }

    // Example 11: Job status and results (mock)
    println!("\n11. Job Status and Results");
    println!("--------------------------");

    for job in jobs.iter().take(3) {
        let status = executor.get_job_status(&job.id)?;
        println!("Job {}: {:?}", job.id, status);

        // Mock getting results for completed jobs
        if status == ExecutionStatus::Queued {
            let result = executor.get_results(&job.id)?;
            println!("  Status: {:?}", result.status);
            println!("  Backends used: {:?}", result.metadata.backends_used);
            println!("  Total time: {:?}", result.metadata.total_time);
            println!("  Queue time: {:?}", result.metadata.queue_time);
            println!("  Resource usage:");
            println!(
                "    CPU hours: {:.3}",
                result.metadata.resource_usage.cpu_hours
            );
            println!(
                "    Memory hours: {:.3}",
                result.metadata.resource_usage.memory_hours
            );
            println!(
                "    Qubit hours: {:.3}",
                result.metadata.resource_usage.qubit_hours
            );
            println!(
                "    Network usage: {:.3} GB",
                result.metadata.resource_usage.network_usage
            );
        }
    }

    // Example 12: Connectivity topologies
    println!("\n12. Connectivity Topologies");
    println!("---------------------------");

    let topologies = vec![
        ("Linear", distributed::TopologyType::Linear),
        (
            "2D Grid (3x3)",
            distributed::TopologyType::Grid2D { rows: 3, cols: 3 },
        ),
        ("All-to-all", distributed::TopologyType::AllToAll),
        (
            "Random (70% density)",
            distributed::TopologyType::Random { density: 0.7 },
        ),
    ];

    for (name, topology) in topologies {
        println!("  {}: {:?}", name, topology);
    }

    println!("\n✅ Distributed Circuit Execution Demo completed!");
    println!("\nNote: This demo shows the distributed execution framework structure.");
    println!("Real distributed execution requires actual quantum backends and networking.");

    Ok(())
}

pub fn add_backend(&mut self, backend: ExecutionBackend) -> QuantRS2Result<()>

Add a backend to the distributed executor

Examples found in repository

examples/distributed_demo.rs (line 40)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 Distributed Circuit Execution Demo");
    println!("====================================\n");

    // Example 1: Setting up a distributed executor
    println!("1. Creating Distributed Executor");
    println!("--------------------------------");

    let mut executor = DistributedExecutor::new();
    println!("Created distributed executor with default configuration");
    println!("  Load balancing: {:?}", executor.load_balancer.strategy);
    println!("  Scheduling policy: {:?}", executor.scheduler.policy);
    println!(
        "  Fault tolerance enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );

    // Example 2: Adding different types of backends
    println!("\n2. Adding Execution Backends");
    println!("----------------------------");

    // Add a quantum hardware backend
    let hardware_backend = create_hardware_backend();
    println!("Adding hardware backend: {}", hardware_backend.id);
    executor.add_backend(hardware_backend)?;

    // Add a simulator backend
    let simulator_backend = create_simulator_backend();
    println!("Adding simulator backend: {}", simulator_backend.id);
    executor.add_backend(simulator_backend)?;

    // Add a cloud service backend
    let cloud_backend = create_cloud_backend();
    println!("Adding cloud backend: {}", cloud_backend.id);
    executor.add_backend(cloud_backend)?;

    // Add a hybrid backend
    let hybrid_backend = create_hybrid_backend();
    println!("Adding hybrid backend: {}", hybrid_backend.id);
    executor.add_backend(hybrid_backend)?;

    println!("Total backends added: {}", executor.backends.len());

    // Example 3: System health status
    println!("\n3. System Health Status");
    println!("-----------------------");

    let health = executor.get_health_status();
    println!("System health:");
    println!("  Total backends: {}", health.total_backends);
    println!("  Available backends: {}", health.available_backends);
    println!("  Total qubits: {}", health.total_qubits);
    println!(
        "  Average queue time: {:.2} seconds",
        health.average_queue_time
    );
    println!("  System load: {:.1}%", health.system_load * 100.0);

    // Example 4: Creating and submitting jobs
    println!("\n4. Creating and Submitting Jobs");
    println!("-------------------------------");

    // Create different types of circuits for testing
    let jobs = create_test_jobs();

    for (i, job) in jobs.iter().enumerate() {
        println!(
            "Job {}: {} ({} qubits, {} gates, priority: {:?})",
            i + 1,
            job.id,
            job.circuit.num_qubits(),
            job.circuit.num_gates(),
            job.priority
        );

        match executor.submit_job(job.clone()) {
            Ok(job_id) => println!("  ✅ Submitted successfully: {}", job_id),
            Err(e) => println!("  ❌ Submission failed: {}", e),
        }
    }

    // Example 5: Different load balancing strategies
    println!("\n5. Load Balancing Strategies");
    println!("----------------------------");

    let strategies = vec![
        ("Round Robin", LoadBalancingStrategy::RoundRobin),
        ("Least Connections", LoadBalancingStrategy::LeastConnections),
        ("Least Queue Time", LoadBalancingStrategy::LeastQueueTime),
        ("Best Performance", LoadBalancingStrategy::BestPerformance),
    ];

    for (name, strategy) in strategies {
        executor.load_balancer.strategy = strategy.clone();
        println!("  {}: {:?}", name, strategy);
    }

    // Example 6: Backend types and capabilities
    println!("\n6. Backend Types and Capabilities");
    println!("---------------------------------");

    for backend in &executor.backends {
        println!("Backend: {} ({:?})", backend.id, backend.status);
        match &backend.backend_type {
            BackendType::Hardware {
                vendor,
                model,
                location,
            } => {
                println!("  Type: Hardware ({} {} in {})", vendor, model, location);
            }
            BackendType::Simulator {
                simulator_type,
                host,
            } => {
                println!("  Type: Simulator ({:?} on {})", simulator_type, host);
            }
            BackendType::CloudService {
                provider,
                service_name,
                region,
            } => {
                println!(
                    "  Type: Cloud ({} {} in {})",
                    provider, service_name, region
                );
            }
            BackendType::Hybrid {
                quantum_backend: _,
                classical_resources,
            } => {
                println!(
                    "  Type: Hybrid ({} CPU cores, {:.1} GB memory)",
                    classical_resources.cpu_cores, classical_resources.memory_gb
                );
            }
        }

        println!("  Capabilities:");
        println!("    Max qubits: {}", backend.performance.max_qubits);
        println!("    Max depth: {}", backend.performance.max_depth);
        println!(
            "    Supported gates: {:?}",
            backend.capabilities.supported_gates
        );
        println!(
            "    Mid-circuit measurements: {}",
            backend.capabilities.mid_circuit_measurements
        );
        println!(
            "    Queue length: {}/{}",
            backend.queue_info.queue_length, backend.queue_info.max_queue_size
        );
        println!(
            "    Estimated wait time: {:.1} seconds",
            backend.queue_info.estimated_wait_time
        );
        println!();
    }

    // Example 7: Execution parameters and error mitigation
    println!("7. Execution Parameters and Error Mitigation");
    println!("--------------------------------------------");

    let error_mitigation_techniques = vec![
        (
            "Readout Error Mitigation",
            ErrorMitigation::ReadoutErrorMitigation,
        ),
        (
            "Zero Noise Extrapolation",
            ErrorMitigation::ZeroNoiseExtrapolation,
        ),
        (
            "Clifford Data Regression",
            ErrorMitigation::CliffordDataRegression,
        ),
        (
            "Symmetry Verification",
            ErrorMitigation::SymmetryVerification,
        ),
    ];

    for (name, technique) in error_mitigation_techniques {
        println!("  {}: {:?}", name, technique);
    }

    let result_formats = vec![
        ("Counts", ResultFormat::Counts),
        ("Probabilities", ResultFormat::Probabilities),
        ("Statevector", ResultFormat::Statevector),
        ("Expectation Values", ResultFormat::ExpectationValues),
    ];

    println!("\nResult formats:");
    for (name, format) in result_formats {
        println!("  {}: {:?}", name, format);
    }

    // Example 8: Fault tolerance and redundancy
    println!("\n8. Fault Tolerance and Redundancy");
    println!("---------------------------------");

    println!("Current fault tolerance configuration:");
    println!(
        "  Failover enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );
    println!(
        "  Error correction: {:?}",
        executor.fault_tolerance.error_correction
    );

    // Demonstrate different error correction strategies
    let error_correction_strategies = vec![
        ("None", ErrorCorrectionStrategy::None),
        ("Majority Voting", ErrorCorrectionStrategy::MajorityVoting),
        (
            "Quantum Error Correction",
            ErrorCorrectionStrategy::QuantumErrorCorrection,
        ),
        (
            "Classical Post-processing",
            ErrorCorrectionStrategy::ClassicalPostProcessing,
        ),
    ];

    println!("\nAvailable error correction strategies:");
    for (name, strategy) in error_correction_strategies {
        println!("  {}: {:?}", name, strategy);
    }

    // Example 9: Resource management and allocation
    println!("\n9. Resource Management and Allocation");
    println!("------------------------------------");

    println!("Resource pool:");
    println!(
        "  Total qubits: {}",
        executor.resource_manager.resource_pool.total_qubits
    );
    println!(
        "  Available slots: {}",
        executor.resource_manager.resource_pool.available_slots
    );
    println!(
        "  Memory pool: {:.1} GB",
        executor.resource_manager.resource_pool.memory_pool
    );
    println!(
        "  Compute pool: {:.1} CPU hours",
        executor.resource_manager.resource_pool.compute_pool
    );

    println!("\nAllocation policies:");
    if let Some(max_qubits) = executor
        .resource_manager
        .allocation_policies
        .max_qubits_per_user
    {
        println!("  Max qubits per user: {}", max_qubits);
    }
    if let Some(max_time) = executor
        .resource_manager
        .allocation_policies
        .max_execution_time
    {
        println!("  Max execution time: {:.1} seconds", max_time);
    }
    println!(
        "  Fair share: {}",
        executor.resource_manager.allocation_policies.fair_share
    );
    println!(
        "  Reserved resources: {:.1}%",
        executor
            .resource_manager
            .allocation_policies
            .reserved_resources
            * 100.0
    );

    // Example 10: Network configuration and authentication
    println!("\n10. Network Configuration and Authentication");
    println!("-------------------------------------------");

    for backend in &executor.backends {
        println!(
            "Backend {}: {}",
            backend.id, backend.network_config.endpoint
        );
        println!(
            "  Auth type: {:?}",
            backend.network_config.credentials.auth_type
        );
        println!(
            "  Connection timeout: {:.1}s",
            backend.network_config.timeouts.connection_timeout
        );
        println!(
            "  Request timeout: {:.1}s",
            backend.network_config.timeouts.request_timeout
        );
        println!(
            "  Max retries: {}",
            backend.network_config.retry_policy.max_retries
        );
        println!(
            "  Backoff strategy: {:?}",
            backend.network_config.retry_policy.backoff_strategy
        );
    }

    // Example 11: Job status and results (mock)
    println!("\n11. Job Status and Results");
    println!("--------------------------");

    for job in jobs.iter().take(3) {
        let status = executor.get_job_status(&job.id)?;
        println!("Job {}: {:?}", job.id, status);

        // Mock getting results for completed jobs
        if status == ExecutionStatus::Queued {
            let result = executor.get_results(&job.id)?;
            println!("  Status: {:?}", result.status);
            println!("  Backends used: {:?}", result.metadata.backends_used);
            println!("  Total time: {:?}", result.metadata.total_time);
            println!("  Queue time: {:?}", result.metadata.queue_time);
            println!("  Resource usage:");
            println!(
                "    CPU hours: {:.3}",
                result.metadata.resource_usage.cpu_hours
            );
            println!(
                "    Memory hours: {:.3}",
                result.metadata.resource_usage.memory_hours
            );
            println!(
                "    Qubit hours: {:.3}",
                result.metadata.resource_usage.qubit_hours
            );
            println!(
                "    Network usage: {:.3} GB",
                result.metadata.resource_usage.network_usage
            );
        }
    }

    // Example 12: Connectivity topologies
    println!("\n12. Connectivity Topologies");
    println!("---------------------------");

    let topologies = vec![
        ("Linear", distributed::TopologyType::Linear),
        (
            "2D Grid (3x3)",
            distributed::TopologyType::Grid2D { rows: 3, cols: 3 },
        ),
        ("All-to-all", distributed::TopologyType::AllToAll),
        (
            "Random (70% density)",
            distributed::TopologyType::Random { density: 0.7 },
        ),
    ];

    for (name, topology) in topologies {
        println!("  {}: {:?}", name, topology);
    }

    println!("\n✅ Distributed Circuit Execution Demo completed!");
    println!("\nNote: This demo shows the distributed execution framework structure.");
    println!("Real distributed execution requires actual quantum backends and networking.");

    Ok(())
}

pub fn submit_job<const N: usize>( &mut self, job: DistributedJob<N>, ) -> QuantRS2Result<String>

Submit a job for distributed execution

Examples found in repository

examples/distributed_demo.rs (line 91)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 Distributed Circuit Execution Demo");
    println!("====================================\n");

    // Example 1: Setting up a distributed executor
    println!("1. Creating Distributed Executor");
    println!("--------------------------------");

    let mut executor = DistributedExecutor::new();
    println!("Created distributed executor with default configuration");
    println!("  Load balancing: {:?}", executor.load_balancer.strategy);
    println!("  Scheduling policy: {:?}", executor.scheduler.policy);
    println!(
        "  Fault tolerance enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );

    // Example 2: Adding different types of backends
    println!("\n2. Adding Execution Backends");
    println!("----------------------------");

    // Add a quantum hardware backend
    let hardware_backend = create_hardware_backend();
    println!("Adding hardware backend: {}", hardware_backend.id);
    executor.add_backend(hardware_backend)?;

    // Add a simulator backend
    let simulator_backend = create_simulator_backend();
    println!("Adding simulator backend: {}", simulator_backend.id);
    executor.add_backend(simulator_backend)?;

    // Add a cloud service backend
    let cloud_backend = create_cloud_backend();
    println!("Adding cloud backend: {}", cloud_backend.id);
    executor.add_backend(cloud_backend)?;

    // Add a hybrid backend
    let hybrid_backend = create_hybrid_backend();
    println!("Adding hybrid backend: {}", hybrid_backend.id);
    executor.add_backend(hybrid_backend)?;

    println!("Total backends added: {}", executor.backends.len());

    // Example 3: System health status
    println!("\n3. System Health Status");
    println!("-----------------------");

    let health = executor.get_health_status();
    println!("System health:");
    println!("  Total backends: {}", health.total_backends);
    println!("  Available backends: {}", health.available_backends);
    println!("  Total qubits: {}", health.total_qubits);
    println!(
        "  Average queue time: {:.2} seconds",
        health.average_queue_time
    );
    println!("  System load: {:.1}%", health.system_load * 100.0);

    // Example 4: Creating and submitting jobs
    println!("\n4. Creating and Submitting Jobs");
    println!("-------------------------------");

    // Create different types of circuits for testing
    let jobs = create_test_jobs();

    for (i, job) in jobs.iter().enumerate() {
        println!(
            "Job {}: {} ({} qubits, {} gates, priority: {:?})",
            i + 1,
            job.id,
            job.circuit.num_qubits(),
            job.circuit.num_gates(),
            job.priority
        );

        match executor.submit_job(job.clone()) {
            Ok(job_id) => println!("  ✅ Submitted successfully: {}", job_id),
            Err(e) => println!("  ❌ Submission failed: {}", e),
        }
    }

    // Example 5: Different load balancing strategies
    println!("\n5. Load Balancing Strategies");
    println!("----------------------------");

    let strategies = vec![
        ("Round Robin", LoadBalancingStrategy::RoundRobin),
        ("Least Connections", LoadBalancingStrategy::LeastConnections),
        ("Least Queue Time", LoadBalancingStrategy::LeastQueueTime),
        ("Best Performance", LoadBalancingStrategy::BestPerformance),
    ];

    for (name, strategy) in strategies {
        executor.load_balancer.strategy = strategy.clone();
        println!("  {}: {:?}", name, strategy);
    }

    // Example 6: Backend types and capabilities
    println!("\n6. Backend Types and Capabilities");
    println!("---------------------------------");

    for backend in &executor.backends {
        println!("Backend: {} ({:?})", backend.id, backend.status);
        match &backend.backend_type {
            BackendType::Hardware {
                vendor,
                model,
                location,
            } => {
                println!("  Type: Hardware ({} {} in {})", vendor, model, location);
            }
            BackendType::Simulator {
                simulator_type,
                host,
            } => {
                println!("  Type: Simulator ({:?} on {})", simulator_type, host);
            }
            BackendType::CloudService {
                provider,
                service_name,
                region,
            } => {
                println!(
                    "  Type: Cloud ({} {} in {})",
                    provider, service_name, region
                );
            }
            BackendType::Hybrid {
                quantum_backend: _,
                classical_resources,
            } => {
                println!(
                    "  Type: Hybrid ({} CPU cores, {:.1} GB memory)",
                    classical_resources.cpu_cores, classical_resources.memory_gb
                );
            }
        }

        println!("  Capabilities:");
        println!("    Max qubits: {}", backend.performance.max_qubits);
        println!("    Max depth: {}", backend.performance.max_depth);
        println!(
            "    Supported gates: {:?}",
            backend.capabilities.supported_gates
        );
        println!(
            "    Mid-circuit measurements: {}",
            backend.capabilities.mid_circuit_measurements
        );
        println!(
            "    Queue length: {}/{}",
            backend.queue_info.queue_length, backend.queue_info.max_queue_size
        );
        println!(
            "    Estimated wait time: {:.1} seconds",
            backend.queue_info.estimated_wait_time
        );
        println!();
    }

    // Example 7: Execution parameters and error mitigation
    println!("7. Execution Parameters and Error Mitigation");
    println!("--------------------------------------------");

    let error_mitigation_techniques = vec![
        (
            "Readout Error Mitigation",
            ErrorMitigation::ReadoutErrorMitigation,
        ),
        (
            "Zero Noise Extrapolation",
            ErrorMitigation::ZeroNoiseExtrapolation,
        ),
        (
            "Clifford Data Regression",
            ErrorMitigation::CliffordDataRegression,
        ),
        (
            "Symmetry Verification",
            ErrorMitigation::SymmetryVerification,
        ),
    ];

    for (name, technique) in error_mitigation_techniques {
        println!("  {}: {:?}", name, technique);
    }

    let result_formats = vec![
        ("Counts", ResultFormat::Counts),
        ("Probabilities", ResultFormat::Probabilities),
        ("Statevector", ResultFormat::Statevector),
        ("Expectation Values", ResultFormat::ExpectationValues),
    ];

    println!("\nResult formats:");
    for (name, format) in result_formats {
        println!("  {}: {:?}", name, format);
    }

    // Example 8: Fault tolerance and redundancy
    println!("\n8. Fault Tolerance and Redundancy");
    println!("---------------------------------");

    println!("Current fault tolerance configuration:");
    println!(
        "  Failover enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );
    println!(
        "  Error correction: {:?}",
        executor.fault_tolerance.error_correction
    );

    // Demonstrate different error correction strategies
    let error_correction_strategies = vec![
        ("None", ErrorCorrectionStrategy::None),
        ("Majority Voting", ErrorCorrectionStrategy::MajorityVoting),
        (
            "Quantum Error Correction",
            ErrorCorrectionStrategy::QuantumErrorCorrection,
        ),
        (
            "Classical Post-processing",
            ErrorCorrectionStrategy::ClassicalPostProcessing,
        ),
    ];

    println!("\nAvailable error correction strategies:");
    for (name, strategy) in error_correction_strategies {
        println!("  {}: {:?}", name, strategy);
    }

    // Example 9: Resource management and allocation
    println!("\n9. Resource Management and Allocation");
    println!("------------------------------------");

    println!("Resource pool:");
    println!(
        "  Total qubits: {}",
        executor.resource_manager.resource_pool.total_qubits
    );
    println!(
        "  Available slots: {}",
        executor.resource_manager.resource_pool.available_slots
    );
    println!(
        "  Memory pool: {:.1} GB",
        executor.resource_manager.resource_pool.memory_pool
    );
    println!(
        "  Compute pool: {:.1} CPU hours",
        executor.resource_manager.resource_pool.compute_pool
    );

    println!("\nAllocation policies:");
    if let Some(max_qubits) = executor
        .resource_manager
        .allocation_policies
        .max_qubits_per_user
    {
        println!("  Max qubits per user: {}", max_qubits);
    }
    if let Some(max_time) = executor
        .resource_manager
        .allocation_policies
        .max_execution_time
    {
        println!("  Max execution time: {:.1} seconds", max_time);
    }
    println!(
        "  Fair share: {}",
        executor.resource_manager.allocation_policies.fair_share
    );
    println!(
        "  Reserved resources: {:.1}%",
        executor
            .resource_manager
            .allocation_policies
            .reserved_resources
            * 100.0
    );

    // Example 10: Network configuration and authentication
    println!("\n10. Network Configuration and Authentication");
    println!("-------------------------------------------");

    for backend in &executor.backends {
        println!(
            "Backend {}: {}",
            backend.id, backend.network_config.endpoint
        );
        println!(
            "  Auth type: {:?}",
            backend.network_config.credentials.auth_type
        );
        println!(
            "  Connection timeout: {:.1}s",
            backend.network_config.timeouts.connection_timeout
        );
        println!(
            "  Request timeout: {:.1}s",
            backend.network_config.timeouts.request_timeout
        );
        println!(
            "  Max retries: {}",
            backend.network_config.retry_policy.max_retries
        );
        println!(
            "  Backoff strategy: {:?}",
            backend.network_config.retry_policy.backoff_strategy
        );
    }

    // Example 11: Job status and results (mock)
    println!("\n11. Job Status and Results");
    println!("--------------------------");

    for job in jobs.iter().take(3) {
        let status = executor.get_job_status(&job.id)?;
        println!("Job {}: {:?}", job.id, status);

        // Mock getting results for completed jobs
        if status == ExecutionStatus::Queued {
            let result = executor.get_results(&job.id)?;
            println!("  Status: {:?}", result.status);
            println!("  Backends used: {:?}", result.metadata.backends_used);
            println!("  Total time: {:?}", result.metadata.total_time);
            println!("  Queue time: {:?}", result.metadata.queue_time);
            println!("  Resource usage:");
            println!(
                "    CPU hours: {:.3}",
                result.metadata.resource_usage.cpu_hours
            );
            println!(
                "    Memory hours: {:.3}",
                result.metadata.resource_usage.memory_hours
            );
            println!(
                "    Qubit hours: {:.3}",
                result.metadata.resource_usage.qubit_hours
            );
            println!(
                "    Network usage: {:.3} GB",
                result.metadata.resource_usage.network_usage
            );
        }
    }

    // Example 12: Connectivity topologies
    println!("\n12. Connectivity Topologies");
    println!("---------------------------");

    let topologies = vec![
        ("Linear", distributed::TopologyType::Linear),
        (
            "2D Grid (3x3)",
            distributed::TopologyType::Grid2D { rows: 3, cols: 3 },
        ),
        ("All-to-all", distributed::TopologyType::AllToAll),
        (
            "Random (70% density)",
            distributed::TopologyType::Random { density: 0.7 },
        ),
    ];

    for (name, topology) in topologies {
        println!("  {}: {:?}", name, topology);
    }

    println!("\n✅ Distributed Circuit Execution Demo completed!");
    println!("\nNote: This demo shows the distributed execution framework structure.");
    println!("Real distributed execution requires actual quantum backends and networking.");

    Ok(())
}

pub fn get_job_status(&self, job_id: &str) -> QuantRS2Result<ExecutionStatus>

Get execution status for a job

Examples found in repository

examples/distributed_demo.rs (line 338)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 Distributed Circuit Execution Demo");
    println!("====================================\n");

    // Example 1: Setting up a distributed executor
    println!("1. Creating Distributed Executor");
    println!("--------------------------------");

    let mut executor = DistributedExecutor::new();
    println!("Created distributed executor with default configuration");
    println!("  Load balancing: {:?}", executor.load_balancer.strategy);
    println!("  Scheduling policy: {:?}", executor.scheduler.policy);
    println!(
        "  Fault tolerance enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );

    // Example 2: Adding different types of backends
    println!("\n2. Adding Execution Backends");
    println!("----------------------------");

    // Add a quantum hardware backend
    let hardware_backend = create_hardware_backend();
    println!("Adding hardware backend: {}", hardware_backend.id);
    executor.add_backend(hardware_backend)?;

    // Add a simulator backend
    let simulator_backend = create_simulator_backend();
    println!("Adding simulator backend: {}", simulator_backend.id);
    executor.add_backend(simulator_backend)?;

    // Add a cloud service backend
    let cloud_backend = create_cloud_backend();
    println!("Adding cloud backend: {}", cloud_backend.id);
    executor.add_backend(cloud_backend)?;

    // Add a hybrid backend
    let hybrid_backend = create_hybrid_backend();
    println!("Adding hybrid backend: {}", hybrid_backend.id);
    executor.add_backend(hybrid_backend)?;

    println!("Total backends added: {}", executor.backends.len());

    // Example 3: System health status
    println!("\n3. System Health Status");
    println!("-----------------------");

    let health = executor.get_health_status();
    println!("System health:");
    println!("  Total backends: {}", health.total_backends);
    println!("  Available backends: {}", health.available_backends);
    println!("  Total qubits: {}", health.total_qubits);
    println!(
        "  Average queue time: {:.2} seconds",
        health.average_queue_time
    );
    println!("  System load: {:.1}%", health.system_load * 100.0);

    // Example 4: Creating and submitting jobs
    println!("\n4. Creating and Submitting Jobs");
    println!("-------------------------------");

    // Create different types of circuits for testing
    let jobs = create_test_jobs();

    for (i, job) in jobs.iter().enumerate() {
        println!(
            "Job {}: {} ({} qubits, {} gates, priority: {:?})",
            i + 1,
            job.id,
            job.circuit.num_qubits(),
            job.circuit.num_gates(),
            job.priority
        );

        match executor.submit_job(job.clone()) {
            Ok(job_id) => println!("  ✅ Submitted successfully: {}", job_id),
            Err(e) => println!("  ❌ Submission failed: {}", e),
        }
    }

    // Example 5: Different load balancing strategies
    println!("\n5. Load Balancing Strategies");
    println!("----------------------------");

    let strategies = vec![
        ("Round Robin", LoadBalancingStrategy::RoundRobin),
        ("Least Connections", LoadBalancingStrategy::LeastConnections),
        ("Least Queue Time", LoadBalancingStrategy::LeastQueueTime),
        ("Best Performance", LoadBalancingStrategy::BestPerformance),
    ];

    for (name, strategy) in strategies {
        executor.load_balancer.strategy = strategy.clone();
        println!("  {}: {:?}", name, strategy);
    }

    // Example 6: Backend types and capabilities
    println!("\n6. Backend Types and Capabilities");
    println!("---------------------------------");

    for backend in &executor.backends {
        println!("Backend: {} ({:?})", backend.id, backend.status);
        match &backend.backend_type {
            BackendType::Hardware {
                vendor,
                model,
                location,
            } => {
                println!("  Type: Hardware ({} {} in {})", vendor, model, location);
            }
            BackendType::Simulator {
                simulator_type,
                host,
            } => {
                println!("  Type: Simulator ({:?} on {})", simulator_type, host);
            }
            BackendType::CloudService {
                provider,
                service_name,
                region,
            } => {
                println!(
                    "  Type: Cloud ({} {} in {})",
                    provider, service_name, region
                );
            }
            BackendType::Hybrid {
                quantum_backend: _,
                classical_resources,
            } => {
                println!(
                    "  Type: Hybrid ({} CPU cores, {:.1} GB memory)",
                    classical_resources.cpu_cores, classical_resources.memory_gb
                );
            }
        }

        println!("  Capabilities:");
        println!("    Max qubits: {}", backend.performance.max_qubits);
        println!("    Max depth: {}", backend.performance.max_depth);
        println!(
            "    Supported gates: {:?}",
            backend.capabilities.supported_gates
        );
        println!(
            "    Mid-circuit measurements: {}",
            backend.capabilities.mid_circuit_measurements
        );
        println!(
            "    Queue length: {}/{}",
            backend.queue_info.queue_length, backend.queue_info.max_queue_size
        );
        println!(
            "    Estimated wait time: {:.1} seconds",
            backend.queue_info.estimated_wait_time
        );
        println!();
    }

    // Example 7: Execution parameters and error mitigation
    println!("7. Execution Parameters and Error Mitigation");
    println!("--------------------------------------------");

    let error_mitigation_techniques = vec![
        (
            "Readout Error Mitigation",
            ErrorMitigation::ReadoutErrorMitigation,
        ),
        (
            "Zero Noise Extrapolation",
            ErrorMitigation::ZeroNoiseExtrapolation,
        ),
        (
            "Clifford Data Regression",
            ErrorMitigation::CliffordDataRegression,
        ),
        (
            "Symmetry Verification",
            ErrorMitigation::SymmetryVerification,
        ),
    ];

    for (name, technique) in error_mitigation_techniques {
        println!("  {}: {:?}", name, technique);
    }

    let result_formats = vec![
        ("Counts", ResultFormat::Counts),
        ("Probabilities", ResultFormat::Probabilities),
        ("Statevector", ResultFormat::Statevector),
        ("Expectation Values", ResultFormat::ExpectationValues),
    ];

    println!("\nResult formats:");
    for (name, format) in result_formats {
        println!("  {}: {:?}", name, format);
    }

    // Example 8: Fault tolerance and redundancy
    println!("\n8. Fault Tolerance and Redundancy");
    println!("---------------------------------");

    println!("Current fault tolerance configuration:");
    println!(
        "  Failover enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );
    println!(
        "  Error correction: {:?}",
        executor.fault_tolerance.error_correction
    );

    // Demonstrate different error correction strategies
    let error_correction_strategies = vec![
        ("None", ErrorCorrectionStrategy::None),
        ("Majority Voting", ErrorCorrectionStrategy::MajorityVoting),
        (
            "Quantum Error Correction",
            ErrorCorrectionStrategy::QuantumErrorCorrection,
        ),
        (
            "Classical Post-processing",
            ErrorCorrectionStrategy::ClassicalPostProcessing,
        ),
    ];

    println!("\nAvailable error correction strategies:");
    for (name, strategy) in error_correction_strategies {
        println!("  {}: {:?}", name, strategy);
    }

    // Example 9: Resource management and allocation
    println!("\n9. Resource Management and Allocation");
    println!("------------------------------------");

    println!("Resource pool:");
    println!(
        "  Total qubits: {}",
        executor.resource_manager.resource_pool.total_qubits
    );
    println!(
        "  Available slots: {}",
        executor.resource_manager.resource_pool.available_slots
    );
    println!(
        "  Memory pool: {:.1} GB",
        executor.resource_manager.resource_pool.memory_pool
    );
    println!(
        "  Compute pool: {:.1} CPU hours",
        executor.resource_manager.resource_pool.compute_pool
    );

    println!("\nAllocation policies:");
    if let Some(max_qubits) = executor
        .resource_manager
        .allocation_policies
        .max_qubits_per_user
    {
        println!("  Max qubits per user: {}", max_qubits);
    }
    if let Some(max_time) = executor
        .resource_manager
        .allocation_policies
        .max_execution_time
    {
        println!("  Max execution time: {:.1} seconds", max_time);
    }
    println!(
        "  Fair share: {}",
        executor.resource_manager.allocation_policies.fair_share
    );
    println!(
        "  Reserved resources: {:.1}%",
        executor
            .resource_manager
            .allocation_policies
            .reserved_resources
            * 100.0
    );

    // Example 10: Network configuration and authentication
    println!("\n10. Network Configuration and Authentication");
    println!("-------------------------------------------");

    for backend in &executor.backends {
        println!(
            "Backend {}: {}",
            backend.id, backend.network_config.endpoint
        );
        println!(
            "  Auth type: {:?}",
            backend.network_config.credentials.auth_type
        );
        println!(
            "  Connection timeout: {:.1}s",
            backend.network_config.timeouts.connection_timeout
        );
        println!(
            "  Request timeout: {:.1}s",
            backend.network_config.timeouts.request_timeout
        );
        println!(
            "  Max retries: {}",
            backend.network_config.retry_policy.max_retries
        );
        println!(
            "  Backoff strategy: {:?}",
            backend.network_config.retry_policy.backoff_strategy
        );
    }

    // Example 11: Job status and results (mock)
    println!("\n11. Job Status and Results");
    println!("--------------------------");

    for job in jobs.iter().take(3) {
        let status = executor.get_job_status(&job.id)?;
        println!("Job {}: {:?}", job.id, status);

        // Mock getting results for completed jobs
        if status == ExecutionStatus::Queued {
            let result = executor.get_results(&job.id)?;
            println!("  Status: {:?}", result.status);
            println!("  Backends used: {:?}", result.metadata.backends_used);
            println!("  Total time: {:?}", result.metadata.total_time);
            println!("  Queue time: {:?}", result.metadata.queue_time);
            println!("  Resource usage:");
            println!(
                "    CPU hours: {:.3}",
                result.metadata.resource_usage.cpu_hours
            );
            println!(
                "    Memory hours: {:.3}",
                result.metadata.resource_usage.memory_hours
            );
            println!(
                "    Qubit hours: {:.3}",
                result.metadata.resource_usage.qubit_hours
            );
            println!(
                "    Network usage: {:.3} GB",
                result.metadata.resource_usage.network_usage
            );
        }
    }

    // Example 12: Connectivity topologies
    println!("\n12. Connectivity Topologies");
    println!("---------------------------");

    let topologies = vec![
        ("Linear", distributed::TopologyType::Linear),
        (
            "2D Grid (3x3)",
            distributed::TopologyType::Grid2D { rows: 3, cols: 3 },
        ),
        ("All-to-all", distributed::TopologyType::AllToAll),
        (
            "Random (70% density)",
            distributed::TopologyType::Random { density: 0.7 },
        ),
    ];

    for (name, topology) in topologies {
        println!("  {}: {:?}", name, topology);
    }

    println!("\n✅ Distributed Circuit Execution Demo completed!");
    println!("\nNote: This demo shows the distributed execution framework structure.");
    println!("Real distributed execution requires actual quantum backends and networking.");

    Ok(())
}

pub fn cancel_job(&mut self, job_id: &str) -> QuantRS2Result<()>

Cancel a job

pub fn get_results(&self, job_id: &str) -> QuantRS2Result<DistributedResult>

Get results for a completed job

Examples found in repository

examples/distributed_demo.rs (line 343)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 Distributed Circuit Execution Demo");
    println!("====================================\n");

    // Example 1: Setting up a distributed executor
    println!("1. Creating Distributed Executor");
    println!("--------------------------------");

    let mut executor = DistributedExecutor::new();
    println!("Created distributed executor with default configuration");
    println!("  Load balancing: {:?}", executor.load_balancer.strategy);
    println!("  Scheduling policy: {:?}", executor.scheduler.policy);
    println!(
        "  Fault tolerance enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );

    // Example 2: Adding different types of backends
    println!("\n2. Adding Execution Backends");
    println!("----------------------------");

    // Add a quantum hardware backend
    let hardware_backend = create_hardware_backend();
    println!("Adding hardware backend: {}", hardware_backend.id);
    executor.add_backend(hardware_backend)?;

    // Add a simulator backend
    let simulator_backend = create_simulator_backend();
    println!("Adding simulator backend: {}", simulator_backend.id);
    executor.add_backend(simulator_backend)?;

    // Add a cloud service backend
    let cloud_backend = create_cloud_backend();
    println!("Adding cloud backend: {}", cloud_backend.id);
    executor.add_backend(cloud_backend)?;

    // Add a hybrid backend
    let hybrid_backend = create_hybrid_backend();
    println!("Adding hybrid backend: {}", hybrid_backend.id);
    executor.add_backend(hybrid_backend)?;

    println!("Total backends added: {}", executor.backends.len());

    // Example 3: System health status
    println!("\n3. System Health Status");
    println!("-----------------------");

    let health = executor.get_health_status();
    println!("System health:");
    println!("  Total backends: {}", health.total_backends);
    println!("  Available backends: {}", health.available_backends);
    println!("  Total qubits: {}", health.total_qubits);
    println!(
        "  Average queue time: {:.2} seconds",
        health.average_queue_time
    );
    println!("  System load: {:.1}%", health.system_load * 100.0);

    // Example 4: Creating and submitting jobs
    println!("\n4. Creating and Submitting Jobs");
    println!("-------------------------------");

    // Create different types of circuits for testing
    let jobs = create_test_jobs();

    for (i, job) in jobs.iter().enumerate() {
        println!(
            "Job {}: {} ({} qubits, {} gates, priority: {:?})",
            i + 1,
            job.id,
            job.circuit.num_qubits(),
            job.circuit.num_gates(),
            job.priority
        );

        match executor.submit_job(job.clone()) {
            Ok(job_id) => println!("  ✅ Submitted successfully: {}", job_id),
            Err(e) => println!("  ❌ Submission failed: {}", e),
        }
    }

    // Example 5: Different load balancing strategies
    println!("\n5. Load Balancing Strategies");
    println!("----------------------------");

    let strategies = vec![
        ("Round Robin", LoadBalancingStrategy::RoundRobin),
        ("Least Connections", LoadBalancingStrategy::LeastConnections),
        ("Least Queue Time", LoadBalancingStrategy::LeastQueueTime),
        ("Best Performance", LoadBalancingStrategy::BestPerformance),
    ];

    for (name, strategy) in strategies {
        executor.load_balancer.strategy = strategy.clone();
        println!("  {}: {:?}", name, strategy);
    }

    // Example 6: Backend types and capabilities
    println!("\n6. Backend Types and Capabilities");
    println!("---------------------------------");

    for backend in &executor.backends {
        println!("Backend: {} ({:?})", backend.id, backend.status);
        match &backend.backend_type {
            BackendType::Hardware {
                vendor,
                model,
                location,
            } => {
                println!("  Type: Hardware ({} {} in {})", vendor, model, location);
            }
            BackendType::Simulator {
                simulator_type,
                host,
            } => {
                println!("  Type: Simulator ({:?} on {})", simulator_type, host);
            }
            BackendType::CloudService {
                provider,
                service_name,
                region,
            } => {
                println!(
                    "  Type: Cloud ({} {} in {})",
                    provider, service_name, region
                );
            }
            BackendType::Hybrid {
                quantum_backend: _,
                classical_resources,
            } => {
                println!(
                    "  Type: Hybrid ({} CPU cores, {:.1} GB memory)",
                    classical_resources.cpu_cores, classical_resources.memory_gb
                );
            }
        }

        println!("  Capabilities:");
        println!("    Max qubits: {}", backend.performance.max_qubits);
        println!("    Max depth: {}", backend.performance.max_depth);
        println!(
            "    Supported gates: {:?}",
            backend.capabilities.supported_gates
        );
        println!(
            "    Mid-circuit measurements: {}",
            backend.capabilities.mid_circuit_measurements
        );
        println!(
            "    Queue length: {}/{}",
            backend.queue_info.queue_length, backend.queue_info.max_queue_size
        );
        println!(
            "    Estimated wait time: {:.1} seconds",
            backend.queue_info.estimated_wait_time
        );
        println!();
    }

    // Example 7: Execution parameters and error mitigation
    println!("7. Execution Parameters and Error Mitigation");
    println!("--------------------------------------------");

    let error_mitigation_techniques = vec![
        (
            "Readout Error Mitigation",
            ErrorMitigation::ReadoutErrorMitigation,
        ),
        (
            "Zero Noise Extrapolation",
            ErrorMitigation::ZeroNoiseExtrapolation,
        ),
        (
            "Clifford Data Regression",
            ErrorMitigation::CliffordDataRegression,
        ),
        (
            "Symmetry Verification",
            ErrorMitigation::SymmetryVerification,
        ),
    ];

    for (name, technique) in error_mitigation_techniques {
        println!("  {}: {:?}", name, technique);
    }

    let result_formats = vec![
        ("Counts", ResultFormat::Counts),
        ("Probabilities", ResultFormat::Probabilities),
        ("Statevector", ResultFormat::Statevector),
        ("Expectation Values", ResultFormat::ExpectationValues),
    ];

    println!("\nResult formats:");
    for (name, format) in result_formats {
        println!("  {}: {:?}", name, format);
    }

    // Example 8: Fault tolerance and redundancy
    println!("\n8. Fault Tolerance and Redundancy");
    println!("---------------------------------");

    println!("Current fault tolerance configuration:");
    println!(
        "  Failover enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );
    println!(
        "  Error correction: {:?}",
        executor.fault_tolerance.error_correction
    );

    // Demonstrate different error correction strategies
    let error_correction_strategies = vec![
        ("None", ErrorCorrectionStrategy::None),
        ("Majority Voting", ErrorCorrectionStrategy::MajorityVoting),
        (
            "Quantum Error Correction",
            ErrorCorrectionStrategy::QuantumErrorCorrection,
        ),
        (
            "Classical Post-processing",
            ErrorCorrectionStrategy::ClassicalPostProcessing,
        ),
    ];

    println!("\nAvailable error correction strategies:");
    for (name, strategy) in error_correction_strategies {
        println!("  {}: {:?}", name, strategy);
    }

    // Example 9: Resource management and allocation
    println!("\n9. Resource Management and Allocation");
    println!("------------------------------------");

    println!("Resource pool:");
    println!(
        "  Total qubits: {}",
        executor.resource_manager.resource_pool.total_qubits
    );
    println!(
        "  Available slots: {}",
        executor.resource_manager.resource_pool.available_slots
    );
    println!(
        "  Memory pool: {:.1} GB",
        executor.resource_manager.resource_pool.memory_pool
    );
    println!(
        "  Compute pool: {:.1} CPU hours",
        executor.resource_manager.resource_pool.compute_pool
    );

    println!("\nAllocation policies:");
    if let Some(max_qubits) = executor
        .resource_manager
        .allocation_policies
        .max_qubits_per_user
    {
        println!("  Max qubits per user: {}", max_qubits);
    }
    if let Some(max_time) = executor
        .resource_manager
        .allocation_policies
        .max_execution_time
    {
        println!("  Max execution time: {:.1} seconds", max_time);
    }
    println!(
        "  Fair share: {}",
        executor.resource_manager.allocation_policies.fair_share
    );
    println!(
        "  Reserved resources: {:.1}%",
        executor
            .resource_manager
            .allocation_policies
            .reserved_resources
            * 100.0
    );

    // Example 10: Network configuration and authentication
    println!("\n10. Network Configuration and Authentication");
    println!("-------------------------------------------");

    for backend in &executor.backends {
        println!(
            "Backend {}: {}",
            backend.id, backend.network_config.endpoint
        );
        println!(
            "  Auth type: {:?}",
            backend.network_config.credentials.auth_type
        );
        println!(
            "  Connection timeout: {:.1}s",
            backend.network_config.timeouts.connection_timeout
        );
        println!(
            "  Request timeout: {:.1}s",
            backend.network_config.timeouts.request_timeout
        );
        println!(
            "  Max retries: {}",
            backend.network_config.retry_policy.max_retries
        );
        println!(
            "  Backoff strategy: {:?}",
            backend.network_config.retry_policy.backoff_strategy
        );
    }

    // Example 11: Job status and results (mock)
    println!("\n11. Job Status and Results");
    println!("--------------------------");

    for job in jobs.iter().take(3) {
        let status = executor.get_job_status(&job.id)?;
        println!("Job {}: {:?}", job.id, status);

        // Mock getting results for completed jobs
        if status == ExecutionStatus::Queued {
            let result = executor.get_results(&job.id)?;
            println!("  Status: {:?}", result.status);
            println!("  Backends used: {:?}", result.metadata.backends_used);
            println!("  Total time: {:?}", result.metadata.total_time);
            println!("  Queue time: {:?}", result.metadata.queue_time);
            println!("  Resource usage:");
            println!(
                "    CPU hours: {:.3}",
                result.metadata.resource_usage.cpu_hours
            );
            println!(
                "    Memory hours: {:.3}",
                result.metadata.resource_usage.memory_hours
            );
            println!(
                "    Qubit hours: {:.3}",
                result.metadata.resource_usage.qubit_hours
            );
            println!(
                "    Network usage: {:.3} GB",
                result.metadata.resource_usage.network_usage
            );
        }
    }

    // Example 12: Connectivity topologies
    println!("\n12. Connectivity Topologies");
    println!("---------------------------");

    let topologies = vec![
        ("Linear", distributed::TopologyType::Linear),
        (
            "2D Grid (3x3)",
            distributed::TopologyType::Grid2D { rows: 3, cols: 3 },
        ),
        ("All-to-all", distributed::TopologyType::AllToAll),
        (
            "Random (70% density)",
            distributed::TopologyType::Random { density: 0.7 },
        ),
    ];

    for (name, topology) in topologies {
        println!("  {}: {:?}", name, topology);
    }

    println!("\n✅ Distributed Circuit Execution Demo completed!");
    println!("\nNote: This demo shows the distributed execution framework structure.");
    println!("Real distributed execution requires actual quantum backends and networking.");

    Ok(())
}

pub fn get_health_status(&self) -> SystemHealthStatus

Get system health status

Examples found in repository

examples/distributed_demo.rs (line 63)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 Distributed Circuit Execution Demo");
    println!("====================================\n");

    // Example 1: Setting up a distributed executor
    println!("1. Creating Distributed Executor");
    println!("--------------------------------");

    let mut executor = DistributedExecutor::new();
    println!("Created distributed executor with default configuration");
    println!("  Load balancing: {:?}", executor.load_balancer.strategy);
    println!("  Scheduling policy: {:?}", executor.scheduler.policy);
    println!(
        "  Fault tolerance enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );

    // Example 2: Adding different types of backends
    println!("\n2. Adding Execution Backends");
    println!("----------------------------");

    // Add a quantum hardware backend
    let hardware_backend = create_hardware_backend();
    println!("Adding hardware backend: {}", hardware_backend.id);
    executor.add_backend(hardware_backend)?;

    // Add a simulator backend
    let simulator_backend = create_simulator_backend();
    println!("Adding simulator backend: {}", simulator_backend.id);
    executor.add_backend(simulator_backend)?;

    // Add a cloud service backend
    let cloud_backend = create_cloud_backend();
    println!("Adding cloud backend: {}", cloud_backend.id);
    executor.add_backend(cloud_backend)?;

    // Add a hybrid backend
    let hybrid_backend = create_hybrid_backend();
    println!("Adding hybrid backend: {}", hybrid_backend.id);
    executor.add_backend(hybrid_backend)?;

    println!("Total backends added: {}", executor.backends.len());

    // Example 3: System health status
    println!("\n3. System Health Status");
    println!("-----------------------");

    let health = executor.get_health_status();
    println!("System health:");
    println!("  Total backends: {}", health.total_backends);
    println!("  Available backends: {}", health.available_backends);
    println!("  Total qubits: {}", health.total_qubits);
    println!(
        "  Average queue time: {:.2} seconds",
        health.average_queue_time
    );
    println!("  System load: {:.1}%", health.system_load * 100.0);

    // Example 4: Creating and submitting jobs
    println!("\n4. Creating and Submitting Jobs");
    println!("-------------------------------");

    // Create different types of circuits for testing
    let jobs = create_test_jobs();

    for (i, job) in jobs.iter().enumerate() {
        println!(
            "Job {}: {} ({} qubits, {} gates, priority: {:?})",
            i + 1,
            job.id,
            job.circuit.num_qubits(),
            job.circuit.num_gates(),
            job.priority
        );

        match executor.submit_job(job.clone()) {
            Ok(job_id) => println!("  ✅ Submitted successfully: {}", job_id),
            Err(e) => println!("  ❌ Submission failed: {}", e),
        }
    }

    // Example 5: Different load balancing strategies
    println!("\n5. Load Balancing Strategies");
    println!("----------------------------");

    let strategies = vec![
        ("Round Robin", LoadBalancingStrategy::RoundRobin),
        ("Least Connections", LoadBalancingStrategy::LeastConnections),
        ("Least Queue Time", LoadBalancingStrategy::LeastQueueTime),
        ("Best Performance", LoadBalancingStrategy::BestPerformance),
    ];

    for (name, strategy) in strategies {
        executor.load_balancer.strategy = strategy.clone();
        println!("  {}: {:?}", name, strategy);
    }

    // Example 6: Backend types and capabilities
    println!("\n6. Backend Types and Capabilities");
    println!("---------------------------------");

    for backend in &executor.backends {
        println!("Backend: {} ({:?})", backend.id, backend.status);
        match &backend.backend_type {
            BackendType::Hardware {
                vendor,
                model,
                location,
            } => {
                println!("  Type: Hardware ({} {} in {})", vendor, model, location);
            }
            BackendType::Simulator {
                simulator_type,
                host,
            } => {
                println!("  Type: Simulator ({:?} on {})", simulator_type, host);
            }
            BackendType::CloudService {
                provider,
                service_name,
                region,
            } => {
                println!(
                    "  Type: Cloud ({} {} in {})",
                    provider, service_name, region
                );
            }
            BackendType::Hybrid {
                quantum_backend: _,
                classical_resources,
            } => {
                println!(
                    "  Type: Hybrid ({} CPU cores, {:.1} GB memory)",
                    classical_resources.cpu_cores, classical_resources.memory_gb
                );
            }
        }

        println!("  Capabilities:");
        println!("    Max qubits: {}", backend.performance.max_qubits);
        println!("    Max depth: {}", backend.performance.max_depth);
        println!(
            "    Supported gates: {:?}",
            backend.capabilities.supported_gates
        );
        println!(
            "    Mid-circuit measurements: {}",
            backend.capabilities.mid_circuit_measurements
        );
        println!(
            "    Queue length: {}/{}",
            backend.queue_info.queue_length, backend.queue_info.max_queue_size
        );
        println!(
            "    Estimated wait time: {:.1} seconds",
            backend.queue_info.estimated_wait_time
        );
        println!();
    }

    // Example 7: Execution parameters and error mitigation
    println!("7. Execution Parameters and Error Mitigation");
    println!("--------------------------------------------");

    let error_mitigation_techniques = vec![
        (
            "Readout Error Mitigation",
            ErrorMitigation::ReadoutErrorMitigation,
        ),
        (
            "Zero Noise Extrapolation",
            ErrorMitigation::ZeroNoiseExtrapolation,
        ),
        (
            "Clifford Data Regression",
            ErrorMitigation::CliffordDataRegression,
        ),
        (
            "Symmetry Verification",
            ErrorMitigation::SymmetryVerification,
        ),
    ];

    for (name, technique) in error_mitigation_techniques {
        println!("  {}: {:?}", name, technique);
    }

    let result_formats = vec![
        ("Counts", ResultFormat::Counts),
        ("Probabilities", ResultFormat::Probabilities),
        ("Statevector", ResultFormat::Statevector),
        ("Expectation Values", ResultFormat::ExpectationValues),
    ];

    println!("\nResult formats:");
    for (name, format) in result_formats {
        println!("  {}: {:?}", name, format);
    }

    // Example 8: Fault tolerance and redundancy
    println!("\n8. Fault Tolerance and Redundancy");
    println!("---------------------------------");

    println!("Current fault tolerance configuration:");
    println!(
        "  Failover enabled: {}",
        executor.fault_tolerance.enable_failover
    );
    println!(
        "  Redundancy level: {}",
        executor.fault_tolerance.redundancy_level
    );
    println!(
        "  Error correction: {:?}",
        executor.fault_tolerance.error_correction
    );

    // Demonstrate different error correction strategies
    let error_correction_strategies = vec![
        ("None", ErrorCorrectionStrategy::None),
        ("Majority Voting", ErrorCorrectionStrategy::MajorityVoting),
        (
            "Quantum Error Correction",
            ErrorCorrectionStrategy::QuantumErrorCorrection,
        ),
        (
            "Classical Post-processing",
            ErrorCorrectionStrategy::ClassicalPostProcessing,
        ),
    ];

    println!("\nAvailable error correction strategies:");
    for (name, strategy) in error_correction_strategies {
        println!("  {}: {:?}", name, strategy);
    }

    // Example 9: Resource management and allocation
    println!("\n9. Resource Management and Allocation");
    println!("------------------------------------");

    println!("Resource pool:");
    println!(
        "  Total qubits: {}",
        executor.resource_manager.resource_pool.total_qubits
    );
    println!(
        "  Available slots: {}",
        executor.resource_manager.resource_pool.available_slots
    );
    println!(
        "  Memory pool: {:.1} GB",
        executor.resource_manager.resource_pool.memory_pool
    );
    println!(
        "  Compute pool: {:.1} CPU hours",
        executor.resource_manager.resource_pool.compute_pool
    );

    println!("\nAllocation policies:");
    if let Some(max_qubits) = executor
        .resource_manager
        .allocation_policies
        .max_qubits_per_user
    {
        println!("  Max qubits per user: {}", max_qubits);
    }
    if let Some(max_time) = executor
        .resource_manager
        .allocation_policies
        .max_execution_time
    {
        println!("  Max execution time: {:.1} seconds", max_time);
    }
    println!(
        "  Fair share: {}",
        executor.resource_manager.allocation_policies.fair_share
    );
    println!(
        "  Reserved resources: {:.1}%",
        executor
            .resource_manager
            .allocation_policies
            .reserved_resources
            * 100.0
    );

    // Example 10: Network configuration and authentication
    println!("\n10. Network Configuration and Authentication");
    println!("-------------------------------------------");

    for backend in &executor.backends {
        println!(
            "Backend {}: {}",
            backend.id, backend.network_config.endpoint
        );
        println!(
            "  Auth type: {:?}",
            backend.network_config.credentials.auth_type
        );
        println!(
            "  Connection timeout: {:.1}s",
            backend.network_config.timeouts.connection_timeout
        );
        println!(
            "  Request timeout: {:.1}s",
            backend.network_config.timeouts.request_timeout
        );
        println!(
            "  Max retries: {}",
            backend.network_config.retry_policy.max_retries
        );
        println!(
            "  Backoff strategy: {:?}",
            backend.network_config.retry_policy.backoff_strategy
        );
    }

    // Example 11: Job status and results (mock)
    println!("\n11. Job Status and Results");
    println!("--------------------------");

    for job in jobs.iter().take(3) {
        let status = executor.get_job_status(&job.id)?;
        println!("Job {}: {:?}", job.id, status);

        // Mock getting results for completed jobs
        if status == ExecutionStatus::Queued {
            let result = executor.get_results(&job.id)?;
            println!("  Status: {:?}", result.status);
            println!("  Backends used: {:?}", result.metadata.backends_used);
            println!("  Total time: {:?}", result.metadata.total_time);
            println!("  Queue time: {:?}", result.metadata.queue_time);
            println!("  Resource usage:");
            println!(
                "    CPU hours: {:.3}",
                result.metadata.resource_usage.cpu_hours
            );
            println!(
                "    Memory hours: {:.3}",
                result.metadata.resource_usage.memory_hours
            );
            println!(
                "    Qubit hours: {:.3}",
                result.metadata.resource_usage.qubit_hours
            );
            println!(
                "    Network usage: {:.3} GB",
                result.metadata.resource_usage.network_usage
            );
        }
    }

    // Example 12: Connectivity topologies
    println!("\n12. Connectivity Topologies");
    println!("---------------------------");

    let topologies = vec![
        ("Linear", distributed::TopologyType::Linear),
        (
            "2D Grid (3x3)",
            distributed::TopologyType::Grid2D { rows: 3, cols: 3 },
        ),
        ("All-to-all", distributed::TopologyType::AllToAll),
        (
            "Random (70% density)",
            distributed::TopologyType::Random { density: 0.7 },
        ),
    ];

    for (name, topology) in topologies {
        println!("  {}: {:?}", name, topology);
    }

    println!("\n✅ Distributed Circuit Execution Demo completed!");
    println!("\nNote: This demo shows the distributed execution framework structure.");
    println!("Real distributed execution requires actual quantum backends and networking.");

    Ok(())
}

Trait Implementations

impl Debug for DistributedExecutor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DistributedExecutor

fn default() -> Self

Returns the “default value” for a type.