Foundry PR 15070 corpus seed fan-out benchmark

corpus_seed_fanout_bench.rs

use std::{env, hint::black_box};

#[derive(Clone)]
struct CorpusEntry {
    tx_seq: Vec<u8>,
    cmp_seq: Vec<u8>,
    is_favored: bool,
}

#[derive(Clone, Default)]
struct Metrics {
    corpus_count: usize,
    favored_items: usize,
}

#[derive(Clone)]
struct WorkerCorpusSeed {
    in_memory_corpus: Vec<CorpusEntry>,
    history_map: Vec<u8>,
    sancov_history_map: Vec<u8>,
    metrics: Metrics,
}

impl WorkerCorpusSeed {
    fn for_worker(mut self, worker_id: usize, worker_count: usize) -> Self {
        if worker_count > 1 {
            self.in_memory_corpus = self
                .in_memory_corpus
                .into_iter()
                .enumerate()
                .filter_map(|(idx, entry)| (idx % worker_count == worker_id).then_some(entry))
                .collect();
            self.metrics.corpus_count = self.in_memory_corpus.len();
            self.metrics.favored_items = self
                .in_memory_corpus
                .iter()
                .filter(|entry| entry.is_favored)
                .count();
        }
        self
    }

    fn clone_for_worker(&self, worker_id: usize, worker_count: usize) -> Self {
        let in_memory_corpus = if worker_count > 1 {
            self.in_memory_corpus
                .iter()
                .enumerate()
                .filter(|(idx, _)| idx % worker_count == worker_id)
                .map(|(_, entry)| entry.clone())
                .collect()
        } else {
            self.in_memory_corpus.clone()
        };

        let mut metrics = self.metrics.clone();
        metrics.corpus_count = in_memory_corpus.len();
        metrics.favored_items = in_memory_corpus
            .iter()
            .filter(|entry| entry.is_favored)
            .count();

        Self {
            in_memory_corpus,
            history_map: self.history_map.clone(),
            sancov_history_map: self.sancov_history_map.clone(),
            metrics,
        }
    }
}

fn seed(entries: usize, tx_bytes: usize, cmp_bytes: usize) -> WorkerCorpusSeed {
    let in_memory_corpus = (0..entries)
        .map(|idx| CorpusEntry {
            tx_seq: vec![idx as u8; tx_bytes],
            cmp_seq: vec![idx as u8; cmp_bytes],
            is_favored: idx % 3 == 0,
        })
        .collect::<Vec<_>>();

    WorkerCorpusSeed {
        history_map: vec![1; 64 * 1024],
        sancov_history_map: vec![2; 64 * 1024],
        metrics: Metrics {
            corpus_count: in_memory_corpus.len(),
            favored_items: in_memory_corpus
                .iter()
                .filter(|entry| entry.is_favored)
                .count(),
        },
        in_memory_corpus,
    }
}

fn parent_fanout(seed: &WorkerCorpusSeed, workers: usize) -> usize {
    let mut total = 0;
    for _ in 0..workers {
        let worker_seed = seed.clone();
        total += worker_seed.in_memory_corpus.len();
        total += worker_seed.history_map.len();
        total += worker_seed.sancov_history_map.len();
        total += worker_seed.metrics.corpus_count;
        total += worker_seed.metrics.favored_items;
        total += worker_seed
            .in_memory_corpus
            .iter()
            .map(|entry| entry.tx_seq.len() + entry.cmp_seq.len())
            .sum::<usize>();
        black_box(worker_seed);
    }
    total
}

fn pr_fanout(seed: &WorkerCorpusSeed, workers: usize) -> usize {
    let mut total = 0;
    for worker_id in 0..workers {
        let worker_seed = seed.clone().for_worker(worker_id, workers);
        total += worker_seed.in_memory_corpus.len();
        total += worker_seed.history_map.len();
        total += worker_seed.sancov_history_map.len();
        total += worker_seed.metrics.corpus_count;
        total += worker_seed.metrics.favored_items;
        total += worker_seed
            .in_memory_corpus
            .iter()
            .map(|entry| entry.tx_seq.len() + entry.cmp_seq.len())
            .sum::<usize>();
        black_box(worker_seed);
    }
    total
}

fn fixed_fanout(seed: &WorkerCorpusSeed, workers: usize) -> usize {
    let mut total = 0;
    for worker_id in 0..workers {
        let worker_seed = seed.clone_for_worker(worker_id, workers);
        total += worker_seed.in_memory_corpus.len();
        total += worker_seed.history_map.len();
        total += worker_seed.sancov_history_map.len();
        total += worker_seed.metrics.corpus_count;
        total += worker_seed.metrics.favored_items;
        total += worker_seed
            .in_memory_corpus
            .iter()
            .map(|entry| entry.tx_seq.len() + entry.cmp_seq.len())
            .sum::<usize>();
        black_box(worker_seed);
    }
    total
}

fn main() {
    let args = env::args().collect::<Vec<_>>();
    let mode = args.get(1).map(String::as_str).unwrap_or("pr");
    let entries = args
        .get(2)
        .and_then(|arg| arg.parse().ok())
        .unwrap_or(10_000);
    let workers = args.get(3).and_then(|arg| arg.parse().ok()).unwrap_or(8);
    let tx_bytes = args.get(4).and_then(|arg| arg.parse().ok()).unwrap_or(512);
    let cmp_bytes = args.get(5).and_then(|arg| arg.parse().ok()).unwrap_or(512);
    let iters = args.get(6).and_then(|arg| arg.parse().ok()).unwrap_or(100);
    let seed = seed(entries, tx_bytes, cmp_bytes);

    let mut total = 0;
    for _ in 0..iters {
        total += match mode {
            "parent" => parent_fanout(&seed, workers),
            "pr" => pr_fanout(&seed, workers),
            "fixed" => fixed_fanout(&seed, workers),
            _ => panic!("mode must be parent, pr, or fixed"),
        };
    }
    println!("{total}");
}