faultscope-collection 0.2.11

Native logical error-rate collection and scheduling for FaultScope
Documentation
use std::collections::{hash_map::Entry, HashMap};
use std::sync::Arc;

use faultscope_core::{
    validate_decoder_batch_formats, validate_decoder_detector_ids, NativeDecoderFactory,
    NativeDecoderWorker, NpError, NpResult,
};

pub(crate) struct WorkerDecoderCache {
    instances: HashMap<usize, Box<dyn NativeDecoderWorker>>,
}

impl WorkerDecoderCache {
    pub(crate) fn new() -> Self {
        Self {
            instances: HashMap::new(),
        }
    }

    pub(crate) fn resolve<'a>(
        &'a mut self,
        task_key: usize,
        factory: Option<&Arc<dyn NativeDecoderFactory>>,
    ) -> NpResult<Option<&'a mut (dyn NativeDecoderWorker + 'a)>> {
        let Some(factory) = factory else {
            return Ok(None);
        };
        let worker = match self.instances.entry(task_key) {
            Entry::Occupied(entry) => entry.into_mut(),
            Entry::Vacant(entry) => {
                validate_decoder_detector_ids(factory.detector_ids())?;
                validate_decoder_batch_formats(factory.batch_formats())?;
                let instance = factory.create_worker().map_err(|err| {
                    NpError::new(format!(
                        "failed to create worker for task key {task_key} backend `{}`: {}",
                        factory.name(),
                        err.message()
                    ))
                })?;
                if instance.name() != factory.name() {
                    return Err(NpError::new(format!(
                        "worker decoder metadata mismatch for task key {task_key} backend `{}`: name expected `{}`, got `{}`",
                        factory.name(),
                        factory.name(),
                        instance.name()
                    )));
                }
                if instance.detector_ids() != factory.detector_ids() {
                    return Err(NpError::new(format!(
                        "worker decoder metadata mismatch for task key {task_key} backend `{}`: detector_ids expected {:?}, got {:?}",
                        factory.name(),
                        factory.detector_ids(),
                        instance.detector_ids()
                    )));
                }
                if instance.observable_ids() != factory.observable_ids() {
                    return Err(NpError::new(format!(
                        "worker decoder metadata mismatch for task key {task_key} backend `{}`: observable_ids expected {:?}, got {:?}",
                        factory.name(),
                        factory.observable_ids(),
                        instance.observable_ids()
                    )));
                }
                validate_decoder_detector_ids(instance.detector_ids())?;
                validate_decoder_batch_formats(instance.batch_formats())?;
                if instance.batch_formats() != factory.batch_formats() {
                    return Err(NpError::new(format!(
                        "worker decoder metadata mismatch for task key {task_key} backend `{}`: batch_formats expected {:?}, got {:?}",
                        factory.name(),
                        factory.batch_formats(),
                        instance.batch_formats()
                    )));
                }
                entry.insert(instance)
            }
        };
        Ok(Some(&mut **worker as &mut (dyn NativeDecoderWorker + 'a)))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::atomic::{AtomicUsize, Ordering};

    use faultscope_core::{
        CorrectionMaskBatch, DecoderCorrectionBatch, DetectorBatchFormat, DetectorBatchView,
    };

    const MASK_FORMAT: [DetectorBatchFormat; 1] = [DetectorBatchFormat::Masks];
    const PACKED_FORMAT: [DetectorBatchFormat; 1] = [DetectorBatchFormat::Packed];

    struct PrototypeDecoder {
        worker_name: &'static str,
        worker_detector_ids: Vec<i64>,
        worker_observable_ids: Vec<i64>,
        worker_batch_formats: &'static [DetectorBatchFormat],
        create_calls: Arc<AtomicUsize>,
        drops: Arc<AtomicUsize>,
    }

    impl NativeDecoderFactory for PrototypeDecoder {
        fn name(&self) -> &str {
            "prototype"
        }

        fn detector_ids(&self) -> &[i64] {
            &[1]
        }

        fn observable_ids(&self) -> &[i64] {
            &[5]
        }

        fn batch_formats(&self) -> &[DetectorBatchFormat] {
            &MASK_FORMAT
        }

        fn create_worker(&self) -> NpResult<Box<dyn NativeDecoderWorker>> {
            self.create_calls.fetch_add(1, Ordering::SeqCst);
            Ok(Box::new(WorkerDecoder {
                name: self.worker_name,
                detector_ids: self.worker_detector_ids.clone(),
                observable_ids: self.worker_observable_ids.clone(),
                batch_formats: self.worker_batch_formats,
                drops: Arc::clone(&self.drops),
            }))
        }
    }

    struct WorkerDecoder {
        name: &'static str,
        detector_ids: Vec<i64>,
        observable_ids: Vec<i64>,
        batch_formats: &'static [DetectorBatchFormat],
        drops: Arc<AtomicUsize>,
    }

    impl Drop for WorkerDecoder {
        fn drop(&mut self) {
            self.drops.fetch_add(1, Ordering::SeqCst);
        }
    }

    impl NativeDecoderWorker for WorkerDecoder {
        fn name(&self) -> &str {
            self.name
        }

        fn detector_ids(&self) -> &[i64] {
            &self.detector_ids
        }

        fn observable_ids(&self) -> &[i64] {
            &self.observable_ids
        }

        fn batch_formats(&self) -> &[DetectorBatchFormat] {
            self.batch_formats
        }

        fn decode_batch(
            &mut self,
            detectors: DetectorBatchView<'_>,
        ) -> NpResult<DecoderCorrectionBatch> {
            Ok(DecoderCorrectionBatch::Masks(CorrectionMaskBatch::new(
                self.observable_ids.clone(),
                vec![
                    faultscope_core::Mask::zero(faultscope_core::word_count(detectors.shots()));
                    self.observable_ids.len()
                ],
                detectors.shots(),
            )?))
        }
    }

    fn prototype(
        worker_name: &'static str,
        worker_detector_ids: Vec<i64>,
        worker_observable_ids: Vec<i64>,
        create_calls: Arc<AtomicUsize>,
        drops: Arc<AtomicUsize>,
    ) -> Arc<dyn NativeDecoderFactory> {
        Arc::new(PrototypeDecoder {
            worker_name,
            worker_detector_ids,
            worker_observable_ids,
            worker_batch_formats: &MASK_FORMAT,
            create_calls,
            drops,
        })
    }

    #[test]
    fn rejects_worker_name_mismatch_before_caching() {
        let drops = Arc::new(AtomicUsize::new(0));
        let prototype = prototype(
            "different",
            vec![1],
            vec![5],
            Arc::new(AtomicUsize::new(0)),
            Arc::clone(&drops),
        );
        let mut cache = WorkerDecoderCache::new();

        let Err(err) = cache.resolve(7, Some(&prototype)) else {
            panic!("worker name mismatch was accepted");
        };

        assert_eq!(
            err.message(),
            "worker decoder metadata mismatch for task key 7 backend `prototype`: name expected `prototype`, got `different`"
        );
        assert_eq!(drops.load(Ordering::SeqCst), 1);
    }

    #[test]
    fn rejects_worker_detector_ids_mismatch_before_caching() {
        let drops = Arc::new(AtomicUsize::new(0));
        let prototype = prototype(
            "prototype",
            vec![2],
            vec![5],
            Arc::new(AtomicUsize::new(0)),
            Arc::clone(&drops),
        );
        let mut cache = WorkerDecoderCache::new();

        let Err(err) = cache.resolve(11, Some(&prototype)) else {
            panic!("worker detector IDs mismatch was accepted");
        };

        assert_eq!(
            err.message(),
            "worker decoder metadata mismatch for task key 11 backend `prototype`: detector_ids expected [1], got [2]"
        );
        assert_eq!(drops.load(Ordering::SeqCst), 1);
    }

    #[test]
    fn rejects_worker_observable_ids_mismatch_before_caching() {
        let drops = Arc::new(AtomicUsize::new(0));
        let prototype = prototype(
            "prototype",
            vec![1],
            vec![8],
            Arc::new(AtomicUsize::new(0)),
            Arc::clone(&drops),
        );
        let mut cache = WorkerDecoderCache::new();

        let Err(err) = cache.resolve(13, Some(&prototype)) else {
            panic!("worker observable IDs mismatch was accepted");
        };

        assert_eq!(
            err.message(),
            "worker decoder metadata mismatch for task key 13 backend `prototype`: observable_ids expected [5], got [8]"
        );
        assert_eq!(drops.load(Ordering::SeqCst), 1);
    }

    #[test]
    fn rejects_worker_batch_formats_mismatch_before_caching() {
        let drops = Arc::new(AtomicUsize::new(0));
        let prototype: Arc<dyn NativeDecoderFactory> = Arc::new(PrototypeDecoder {
            worker_name: "prototype",
            worker_detector_ids: vec![1],
            worker_observable_ids: vec![5],
            worker_batch_formats: &PACKED_FORMAT,
            create_calls: Arc::new(AtomicUsize::new(0)),
            drops: Arc::clone(&drops),
        });
        let mut cache = WorkerDecoderCache::new();

        let Err(err) = cache.resolve(15, Some(&prototype)) else {
            panic!("worker batch format mismatch was accepted");
        };

        assert_eq!(
            err.message(),
            "worker decoder metadata mismatch for task key 15 backend `prototype`: batch_formats expected [Masks], got [Packed]"
        );
        assert_eq!(drops.load(Ordering::SeqCst), 1);
    }

    #[test]
    fn caches_one_worker_per_task_key() {
        let create_calls = Arc::new(AtomicUsize::new(0));
        let drops = Arc::new(AtomicUsize::new(0));
        let prototype = prototype(
            "prototype",
            vec![1],
            vec![5],
            Arc::clone(&create_calls),
            Arc::clone(&drops),
        );
        let mut cache = WorkerDecoderCache::new();

        assert!(cache.resolve(17, Some(&prototype)).unwrap().is_some());
        assert!(cache.resolve(17, Some(&prototype)).unwrap().is_some());

        assert_eq!(create_calls.load(Ordering::SeqCst), 1);
        drop(cache);
        assert_eq!(drops.load(Ordering::SeqCst), 1);
    }
}