rsinter 0.4.0

Experimental parallel sampling and decoder benchmark harness for RustQEC
Documentation
use std::sync::mpsc::{SyncSender, sync_channel};
use std::thread::JoinHandle;

use rilpqec::{BackendKind, IlpDecoderConfig};
use rstim::dem::DetectorErrorModel;

use crate::decode::{CompiledDecoder, Decoder};

pub struct IlpDemDecoder {
    config: IlpDecoderConfig,
}

impl IlpDemDecoder {
    pub fn new(config: IlpDecoderConfig) -> Self {
        Self { config }
    }
}

impl Default for IlpDemDecoder {
    fn default() -> Self {
        let mut config = IlpDecoderConfig::default();
        config.backend.kind = BackendKind::Auto;
        Self::new(config)
    }
}

struct CompiledIlpDemDecoder {
    requests: Option<SyncSender<DecodeRequest>>,
    worker: Option<JoinHandle<()>>,
}

struct DecodeRequest {
    dets: Vec<u8>,
    num_shots: usize,
    num_dets: usize,
    num_obs: usize,
    response: SyncSender<Result<Vec<u8>, String>>,
}

impl Decoder for IlpDemDecoder {
    fn compile_for_dem(
        &self,
        dem: &DetectorErrorModel,
    ) -> Result<Box<dyn CompiledDecoder>, String> {
        let dem_text = dem.to_string();
        let config = self.config.clone();
        let (requests, request_receiver) = sync_channel::<DecodeRequest>(0);
        let (ready_sender, ready_receiver) = sync_channel(0);
        let worker = std::thread::Builder::new()
            .name("rsinter-rilpqec".into())
            .spawn(move || {
                let decoder = DetectorErrorModel::parse(&dem_text)
                    .map_err(|error| error.to_string())
                    .and_then(|dem| {
                        rilpqec::IlpDemDecoder::from_dem(&dem, config)
                            .map_err(|error| error.to_string())
                    })
                    .and_then(|decoder| decoder.into_compiled().map_err(|error| error.to_string()));
                let mut decoder = match decoder {
                    Ok(decoder) => {
                        if ready_sender.send(Ok(())).is_err() {
                            return;
                        }
                        decoder
                    }
                    Err(error) => {
                        let _ = ready_sender.send(Err(error));
                        return;
                    }
                };
                while let Ok(request) = request_receiver.recv() {
                    let result = decoder
                        .decode_batch_bit_packed(
                            &request.dets,
                            request.num_shots,
                            request.num_dets,
                            request.num_obs,
                        )
                        .map_err(|error| error.to_string());
                    let _ = request.response.send(result);
                }
            })
            .map_err(|error| format!("failed to start rilpqec worker: {error}"))?;
        match ready_receiver.recv() {
            Ok(Ok(())) => {}
            Ok(Err(error)) => {
                let _ = worker.join();
                return Err(error);
            }
            Err(error) => {
                let _ = worker.join();
                return Err(format!(
                    "rilpqec worker stopped during compilation: {error}"
                ));
            }
        }
        Ok(Box::new(CompiledIlpDemDecoder {
            requests: Some(requests),
            worker: Some(worker),
        }))
    }
}

impl CompiledDecoder for CompiledIlpDemDecoder {
    fn decode_shots_bit_packed(
        &self,
        dets: &[u8],
        num_shots: usize,
        num_dets: usize,
        num_obs: usize,
    ) -> Result<Vec<u8>, String> {
        let (response, response_receiver) = sync_channel(0);
        self.requests
            .as_ref()
            .ok_or_else(|| "rilpqec worker is unavailable".to_string())?
            .send(DecodeRequest {
                dets: dets.to_vec(),
                num_shots,
                num_dets,
                num_obs,
                response,
            })
            .map_err(|error| format!("failed to submit rilpqec batch: {error}"))?;
        response_receiver
            .recv()
            .map_err(|error| format!("rilpqec worker stopped while decoding: {error}"))?
    }
}

impl Drop for CompiledIlpDemDecoder {
    fn drop(&mut self) {
        self.requests.take();
        if let Some(worker) = self.worker.take() {
            let _ = worker.join();
        }
    }
}