lift-predict 0.4.3

LIFT compiler performance prediction: analytical roofline model and budget enforcement for GPU/QPU workloads
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use lift_sim::analysis::AnalysisReport;
use lift_sim::cost::CostModel;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RooflineResult {
    pub compute_time_ms: f64,
    pub memory_time_ms: f64,
    pub predicted_time_ms: f64,
    pub arithmetic_intensity: f64,
    pub is_compute_bound: bool,
    pub bottleneck: String,
}

pub fn predict_performance(report: &AnalysisReport, cost_model: &CostModel) -> RooflineResult {
    let compute_ms = cost_model.compute_time_ms(report.total_flops);
    let memory_ms = cost_model.memory_time_ms(report.total_memory_bytes);
    let predicted_ms = compute_ms.max(memory_ms);
    let ai = cost_model.arithmetic_intensity(report.total_flops, report.total_memory_bytes);
    let compute_bound = cost_model.is_compute_bound(report.total_flops, report.total_memory_bytes);

    RooflineResult {
        compute_time_ms: compute_ms,
        memory_time_ms: memory_ms,
        predicted_time_ms: predicted_ms,
        arithmetic_intensity: ai,
        is_compute_bound: compute_bound,
        bottleneck: if compute_bound {
            "compute".into()
        } else {
            "memory".into()
        },
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumPrediction {
    pub estimated_fidelity: f64,
    pub circuit_time_us: f64,
    pub num_shots_for_precision: usize,
    pub total_execution_time_ms: f64,
}

pub fn predict_quantum(
    analysis: &lift_sim::quantum_sim::QuantumAnalysis,
    cost_model: &lift_sim::cost::QuantumCostModel,
    target_precision: f64,
) -> QuantumPrediction {
    let circuit_time = cost_model.circuit_time_us(
        analysis.one_qubit_gates,
        analysis.two_qubit_gates,
        analysis.measurements,
        analysis.circuit_depth,
    );

    let decoherence_fid = cost_model.decoherence_fidelity(circuit_time);
    let gate_fid = analysis.estimated_fidelity;
    let total_fidelity = gate_fid * decoherence_fid;

    // Shots needed: 1/precision^2 / fidelity
    let num_shots =
        ((1.0 / (target_precision * target_precision)) / total_fidelity).ceil() as usize;
    let total_time_ms = (num_shots as f64 * circuit_time) / 1000.0;

    QuantumPrediction {
        estimated_fidelity: total_fidelity,
        circuit_time_us: circuit_time,
        num_shots_for_precision: num_shots,
        total_execution_time_ms: total_time_ms,
    }
}