Struct BenchmarkResults 

pub struct BenchmarkResults { /* private fields */ }

Aggregated benchmark results

Implementations

impl BenchmarkResults

pub fn summaries(&self) -> &HashMap<String, BenchmarkSummary>

Get summaries

Examples found in repository

examples/comprehensive_benchmarking_demo.rs (line 110)

fn print_performance_summary(results: &BenchmarkResults) {
    println!("\n   Performance Summary:");
    println!("   ===================");

    // Print summaries for each benchmark
    for (name, summary) in results.summaries() {
        println!("   {}:", name);
        println!("     - Mean time: {:.3}s", summary.mean_time.as_secs_f64());
        println!("     - Min time:  {:.3}s", summary.min_time.as_secs_f64());
        println!("     - Max time:  {:.3}s", summary.max_time.as_secs_f64());
        println!("     - Success rate: {:.1}%", summary.success_rate * 100.0);
        if let Some(memory) = summary.mean_memory {
            println!(
                "     - Memory usage: {:.1} MB",
                memory as f64 / 1024.0 / 1024.0
            );
        }
        println!();
    }
}

fn print_scaling_analysis(results: &BenchmarkResults) {
    println!("   Scaling Analysis:");
    println!("   =================");

    // Group by algorithm type
    let mut vqe_results = Vec::new();
    let mut qaoa_results = Vec::new();
    let mut qnn_results = Vec::new();

    for (name, summary) in results.summaries() {
        if name.starts_with("vqe_") {
            vqe_results.push((name, summary));
        } else if name.starts_with("qaoa_") {
            qaoa_results.push((name, summary));
        } else if name.starts_with("qnn_") {
            qnn_results.push((name, summary));
        }
    }

    // Analyze VQE scaling
    if !vqe_results.is_empty() {
        println!("   VQE Algorithm Scaling:");
        vqe_results.sort_by_key(|(name, _)| name.clone());
        for (name, summary) in vqe_results {
            let qubits = extract_qubit_count(name);
            println!(
                "     - {} qubits: {:.3}s",
                qubits,
                summary.mean_time.as_secs_f64()
            );
        }
        println!("     - Scaling trend: Exponential (as expected for VQE)");
        println!();
    }

    // Analyze QAOA scaling
    if !qaoa_results.is_empty() {
        println!("   QAOA Algorithm Scaling:");
        qaoa_results.sort_by_key(|(name, _)| name.clone());
        for (name, summary) in qaoa_results {
            let qubits = extract_qubit_count(name);
            println!(
                "     - {} qubits: {:.3}s",
                qubits,
                summary.mean_time.as_secs_f64()
            );
        }
        println!("     - Scaling trend: Polynomial (as expected for QAOA)");
        println!();
    }

    // Analyze QNN scaling
    if !qnn_results.is_empty() {
        println!("   QNN Algorithm Scaling:");
        qnn_results.sort_by_key(|(name, _)| name.clone());
        for (name, summary) in qnn_results {
            let qubits = extract_qubit_count(name);
            println!(
                "     - {} qubits: {:.3}s",
                qubits,
                summary.mean_time.as_secs_f64()
            );
        }
        println!("     - Scaling trend: Polynomial (training overhead)");
        println!();
    }
}

fn print_memory_analysis(results: &BenchmarkResults) {
    println!("   Memory Usage Analysis:");
    println!("   =====================");

    let mut memory_data = Vec::new();
    for (name, summary) in results.summaries() {
        if let Some(memory) = summary.mean_memory {
            let qubits = extract_qubit_count(name);
            memory_data.push((qubits, memory, name));
        }
    }

    if !memory_data.is_empty() {
        memory_data.sort_by_key(|(qubits, _, _)| *qubits);

        println!("   Memory scaling by qubit count:");
        for (qubits, memory, name) in memory_data {
            println!(
                "     - {} qubits ({}): {:.1} MB",
                qubits,
                name,
                memory as f64 / 1024.0 / 1024.0
            );
        }
        println!("     - Expected scaling: O(2^n) for statevector simulation");
        println!();
    }

    // Print recommendations
    println!("   Recommendations:");
    println!("     - Use statevector backend for circuits ≤ 12 qubits");
    println!("     - Use MPS backend for larger circuits with limited entanglement");
    println!("     - Consider circuit optimization for memory-constrained environments");
}

fn extract_qubit_count(benchmark_name: &str) -> usize {
    // Extract number from strings like "vqe_4q_statevector", "qaoa_6q_mps", etc.
    for part in benchmark_name.split('_') {
        if part.ends_with('q') {
            if let Ok(num) = part.trim_end_matches('q').parse::<usize>() {
                return num;
            }
        }
    }
    0 // Default if not found
}

// Additional analysis functions
fn analyze_backend_performance(results: &BenchmarkResults) {
    println!("   Backend Performance Comparison:");
    println!("   ==============================");

    // Group results by backend type
    let mut backend_performance = std::collections::HashMap::new();

    for (name, summary) in results.summaries() {
        let backend_type = extract_backend_type(name);
        backend_performance
            .entry(backend_type)
            .or_insert_with(Vec::new)
            .push(summary.mean_time.as_secs_f64());
    }

    for (backend, times) in backend_performance {
        let avg_time = times.iter().sum::<f64>() / times.len() as f64;
        println!("     - {} backend: {:.3}s average", backend, avg_time);
    }
}

pub fn results(&self) -> &HashMap<String, Vec<BenchmarkRunResult>>

Get results

pub fn metadata(&self) -> &BenchmarkMetadata

Get metadata

Trait Implementations

impl Clone for BenchmarkResults

fn clone(&self) -> BenchmarkResults

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BenchmarkResults

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

Formats the value using the given formatter.