Struct QAOABenchmark 

pub struct QAOABenchmark { /* private fields */ }

QAOA benchmark

Implementations

impl QAOABenchmark

pub fn new(num_qubits: usize, num_layers: usize, problem_size: usize) -> Self

Examples found in repository

examples/comprehensive_benchmarking_demo.rs (line 58)

fn main() -> Result<()> {
    println!("=== Comprehensive Quantum ML Benchmarking Demo ===\n");

    // Step 1: Initialize benchmarking framework
    println!("1. Initializing benchmarking framework...");

    let config = BenchmarkConfig {
        repetitions: 3,
        warmup_runs: 1,
        max_time_per_benchmark: 60.0, // 1 minute per benchmark
        profile_memory: true,
        analyze_convergence: true,
        confidence_level: 0.95,
        ..Default::default()
    };

    let mut framework = BenchmarkFramework::new().with_config(config);

    println!("   - Framework initialized");
    println!("   - Output directory: benchmark_results/");
    println!("   - Repetitions per benchmark: 3");

    // Step 2: Register benchmarks
    println!("\n2. Registering benchmarks...");

    // VQE benchmarks for different qubit counts
    framework.register_benchmark("vqe_4q", Box::new(VQEBenchmark::new(4, 8)));
    framework.register_benchmark("vqe_6q", Box::new(VQEBenchmark::new(6, 12)));
    framework.register_benchmark("vqe_8q", Box::new(VQEBenchmark::new(8, 16)));

    // QAOA benchmarks
    framework.register_benchmark("qaoa_4q", Box::new(QAOABenchmark::new(4, 2, 8)));
    framework.register_benchmark("qaoa_6q", Box::new(QAOABenchmark::new(6, 3, 12)));

    // QNN benchmarks
    framework.register_benchmark("qnn_4q", Box::new(QNNBenchmark::new(4, 2, 100)));
    framework.register_benchmark("qnn_6q", Box::new(QNNBenchmark::new(6, 3, 100)));

    println!("   - Registered 7 benchmarks total");

    // Step 3: Create backend configurations
    println!("\n3. Setting up backends...");

    let backends = create_benchmark_backends();
    let backend_refs: Vec<&Backend> = backends.iter().collect();

    println!("   - Created {} backends", backends.len());
    for backend in &backends {
        println!("     - {}", backend.name());
    }

    // Step 4: Run all benchmarks
    println!("\n4. Running all benchmarks...");

    framework.run_all_benchmarks(&backend_refs)?;

    println!("   - All benchmarks completed");

    // Step 5: Generate and display report
    println!("\n5. Generating benchmark report...");

    let report = framework.generate_report();
    println!("\n{}", report.to_string());

    // Step 6: Print detailed results
    println!("\n6. Detailed Results Analysis:");

    // Get results again for analysis since we can't hold onto the reference
    let results = framework.run_all_benchmarks(&backend_refs)?;
    print_performance_summary(results);
    print_scaling_analysis(results);
    print_memory_analysis(results);

    println!("\n=== Comprehensive Benchmarking Demo Complete ===");

    Ok(())
}

Trait Implementations

impl Benchmark for QAOABenchmark

fn name(&self) -> &str

Get benchmark name

fn description(&self) -> &str

Get benchmark description

fn setup(&mut self) -> Result<()>

Setup benchmark (called once before all runs)

fn run(&mut self, _backend: &Backend) -> Result<BenchmarkRunResult>

Run single benchmark iteration

fn cleanup(&mut self) -> Result<()>

Cleanup after benchmark

fn expected_scaling(&self) -> ScalingType

Get expected scaling behavior

fn category(&self) -> BenchmarkCategory

Get benchmark category