Function save_block_coverage

hail-fuzz/src/debugging/replay.rs:40–91

(mut config: Config, mode: SaveMode)

}

pub fn save_block_coverage(mut config: Config, mode: SaveMode) -> anyhow::Result<()> {
    let mut testcases: Vec<InputMetadata> = load_json(&config.workdir.join("testcases.json"))?;
    testcases.sort_by_key(|x| x.found_at);

    let features = config::EnabledFeatures::from_env()?;
    let (mut target, mut vm) = setup_vm(&mut config, &features)?;
    target.initialize_vm(&config.fuzzer, &mut vm)?;

    let mut coverage =
        crate::coverage::BlockCoverage::init(&mut vm, crate::coverage::BucketStrategy::Any, true);

    let snapshot = vm.snapshot();

    let mut all_blocks = vec![];
    let mut block_map = HashMap::new();
    let mut output = vec![];
    for case in testcases {
        vm.restore(&snapshot);
        coverage.reset(&mut vm);

        let input = MultiStream::from_path(&config.workdir.join(format!("queue/{}.bin", case.id)))?;
        target.get_mmio_handler(&mut vm).unwrap().clone_from(&input);

        target.run(&mut vm)?;

        let blocks = coverage.get_blocks(&mut vm);
        let hits = blocks
            .into_iter()
            .map(|addr| {
                *block_map.entry(addr).or_insert_with(|| {
                    let id = all_blocks.len();
                    all_blocks.push((addr, case.found_at, case.id));
                    id
                })
            })
            .collect::<Vec<_>>();

        output.push(serde_json::json!({
            "id": case.id,
            "time_ms": case.found_at,
            "hits": hits,
        }));
    }

    let out = match mode {
        SaveMode::Full => serde_json::json!({ "blocks": all_blocks, "inputs": output }),
        SaveMode::BlocksOnly => serde_json::json!(all_blocks),
    };
    write!(std::io::stdout(), "{out}")?;

    Ok(())
}

pub fn replay(mut config: Config, path: &str) -> anyhow::Result<()> {
    let features = config::EnabledFeatures::from_env()?;