rsinter 0.4.0

Experimental parallel sampling and decoder benchmark harness for RustQEC
Documentation
use std::collections::BTreeMap;
use std::path::Path;

use serde::Deserialize;

use crate::bench::result::{BenchmarkResultRow, CaseSummary, MetricMap, ParamMap};
use crate::failure::{classify_completed, classify_error, FailureKind};

#[derive(Debug, Deserialize)]
struct SurfaceCompareCsvRow {
    tier: String,
    decoder: String,
    backend: String,
    distance: u64,
    rounds: u64,
    p: f64,
    seed: u64,
    num_dets: u64,
    num_obs: u64,
    shots_budget: u64,
    errors_budget: u64,
    shots_used: u64,
    logical_errors: u64,
    logical_error_rate: f64,
    compile_us: f64,
    total_decode_us: f64,
    decode_us_per_shot: f64,
    status: String,
    error: String,
}

pub fn read_surface_compare_csv(
    path: &Path,
    benchmark_name: &str,
) -> Result<Vec<BenchmarkResultRow>, String> {
    let mut reader = csv::Reader::from_path(path).map_err(|e| e.to_string())?;
    reader
        .deserialize::<SurfaceCompareCsvRow>()
        .map(|row| row.map_err(|e| e.to_string()))
        .map(|row| row.map(|row| row.into_benchmark_row(benchmark_name)))
        .collect()
}

impl SurfaceCompareCsvRow {
    fn into_benchmark_row(self, benchmark_name: &str) -> BenchmarkResultRow {
        let error = if self.error.trim().is_empty() {
            None
        } else {
            Some(self.error)
        };
        let failure_kind = if self.status == "ok" {
            classify_completed(self.logical_errors, false)
        } else {
            error
                .as_deref()
                .map(|message| classify_error(message, FailureKind::SolverFailure))
                .unwrap_or(FailureKind::SolverFailure)
        };

        BenchmarkResultRow {
            benchmark: benchmark_name.into(),
            runner: self.decoder.clone(),
            language: language_for_decoder(&self.decoder).into(),
            status: self.status,
            failure_kind,
            params: ParamMap::from([
                ("backend".into(), serde_json::json!(self.backend)),
                ("distance".into(), serde_json::json!(self.distance)),
                (
                    "errors_budget".into(),
                    serde_json::json!(self.errors_budget),
                ),
                ("max_errors".into(), serde_json::json!(self.errors_budget)),
                ("max_shots".into(), serde_json::json!(self.shots_budget)),
                ("p".into(), serde_json::json!(self.p)),
                ("rounds".into(), serde_json::json!(self.rounds)),
                ("seed".into(), serde_json::json!(self.seed)),
                ("shots_budget".into(), serde_json::json!(self.shots_budget)),
                ("tier".into(), serde_json::json!(self.tier)),
            ]),
            case_summary: CaseSummary::from([
                (
                    "logical_observable_count".into(),
                    serde_json::json!(self.num_obs),
                ),
                ("num_dets".into(), serde_json::json!(self.num_dets)),
                ("num_obs".into(), serde_json::json!(self.num_obs)),
            ]),
            metrics: MetricMap::from([
                ("compile_us".into(), self.compile_us),
                ("decode_us_per_shot".into(), self.decode_us_per_shot),
                ("logical_error_rate".into(), self.logical_error_rate),
                ("logical_errors".into(), self.logical_errors as f64),
                ("shots_used".into(), self.shots_used as f64),
                ("total_decode_us".into(), self.total_decode_us),
            ]),
            artifacts: BTreeMap::new(),
            error,
        }
    }
}

fn language_for_decoder(decoder: &str) -> &'static str {
    match decoder {
        "rmatching" | "rbposd" | "rilpqec" => "rust",
        "pymatching" | "ilpqec" | "ldpc" => "python",
        _ => "legacy",
    }
}