make corpus-blame subcommand fast

Author: baflor

src/cli/cov_html.rs

@@ -1,7 +1,7 @@
 use crate::HashMap;
 use crate::instrumentation::BBCoveragePass;
 use crate::ir::debuginfo_helper::resolve_source_location;
-use std::collections::BTreeSet;
+use std::collections::{BTreeMap, BTreeSet};
 use std::fmt::Write;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -149,6 +149,12 @@ pub(crate) struct ReportInfo {
     mod_spec: Arc<ModuleSpec>,
     pub(crate) files: Vec<FileInfo>,
     path_to_fileid: HashMap<String, FileId>,
+    online_cache: Option<OnlineCache>,
+}
+
+struct OnlineCache {
+    covered_keys: crate::HashSet<Location>,
+    offset_lookup: BTreeMap<u64, Box<[(FileId, u32)]>>,
 }
 
 impl ReportInfo {
@@ -185,9 +191,83 @@ impl ReportInfo {
             mod_spec,
             files,
             path_to_fileid,
+            online_cache: None,
         })
     }
 
+    pub(crate) fn process_line_coverage_online(&mut self, sess: &JitFuzzingSession) {
+        tracy_full::zone!("process_line_coverage_online");
+        let first = self.online_cache.is_none();
+        let cache = self.online_cache.get_or_insert_with(|| {
+            tracy_full::zone!("process_line_coverage_online: compute cache");
+            let offset_lookup = self
+                .mod_spec
+                .functions
+                .iter()
+                .flat_map(|func| {
+                    func.operator_offset_rel.iter().map(|rel| {
+                        let addr = func.operators_wasm_bin_offset_base as u64 + *rel as u64;
+                        let mut locs = Vec::new();
+                        resolve_source_location(&self.mod_spec, addr, |x| {
+                            for x in x {
+                                if x.line() == 0 {
+                                    continue;
+                                }
+                                if let Some(file) = x.file() {
+                                    let file_id = self.path_to_fileid[&file.full_path()];
+                                    locs.push((file_id, x.line() - 1))
+                                }
+                            }
+                        });
+
+                        (addr, locs.into_boxed_slice())
+                    })
+                })
+                .collect();
+            OnlineCache {
+                covered_keys: crate::HashSet::default(),
+                offset_lookup,
+            }
+        });
+        if first {
+            tracy_full::zone!("process_line_coverage_online: mark instrumented");
+            for locs in cache.offset_lookup.values() {
+                for (file_id, line) in locs {
+                    self.files[file_id.0 as usize]
+                        .line_coverage
+                        .set_instrumented(*line as usize);
+                }
+            }
+        }
+        let mut new_coverage = Vec::new();
+        {
+            tracy_full::zone!("process_line_coverage_online: scan coverage");
+            for loc in sess
+                .get_pass::<BBCoveragePass>()
+                .coverage
+                .iter_covered_keys()
+            {
+                if cache.covered_keys.insert(loc) {
+                    new_coverage.push(loc);
+                }
+            }
+        }
+
+        {
+            tracy_full::zone!("process_line_coverage_online: mark covered");
+            for loc in new_coverage {
+                let func = &self.mod_spec.functions[loc.function as usize];
+                let base = func.operators_wasm_bin_offset_base as u64;
+                let offset = func.operator_offset_rel[loc.index as usize] as u64;
+                for (file_id, line) in &cache.offset_lookup[&(base + offset)] {
+                    self.files[file_id.0 as usize]
+                        .line_coverage
+                        .set_covered(*line as usize);
+                }
+            }
+        }
+    }
+
     pub(crate) fn process_line_coverage(&mut self, sess: &JitFuzzingSession) {
         tracy_full::zone!("ReportInfo::process_line_coverage");
         let mod_spec = self.mod_spec.clone();

src/cli/mod.rs

@@ -257,16 +257,17 @@ pub(crate) fn main() {
             if inputs.is_empty() {
                 println!("No input specified. Exiting.")
             }
+
+            let size_limit = input_size_limit.unwrap_or(crate::TEST_CASE_SIZE_LIMIT);
+            assert!(size_limit <= crate::TEST_CASE_SIZE_LIMIT);
+
             for input in inputs {
                 println!("Testcase: {input:?}");
                 let testcase = std::fs::read(&input).expect("couldn't read input");
                 let size = testcase.len();
-                assert!(size <= crate::TEST_CASE_SIZE_LIMIT);
-                if let Some(size_limit) = input_size_limit
-                    && size > size_limit
-                {
+                if size > size_limit {
                     println!(
-                        "Testcase: {input:?}: skipped due to size limit ({size} > {size_limit}"
+                        "Testcase: {input:?}: skipped due to size limit ({size} > {size_limit})"
                     );
                     continue;
                 }
@@ -843,12 +844,13 @@ pub(crate) fn main() {
             };
             blame(&report_info, "<init>", &mut res);
 
-            for (path, input) in corpus_entries {
-                print!("blaming {:?}: run                           \r", path);
+            let total = corpus_entries.len();
+            for (i, (path, input)) in corpus_entries.into_iter().enumerate() {
+                print!("[{i}/{total}] blaming {path:?}: run                           \r");
                 sess.run(&input, &mut stats).expect_ok();
-                print!("blaming {:?}: process                       \r", path);
-                report_info.process_line_coverage(&sess);
-                print!("blaming {:?}: blame                         \r", path);
+                print!("[{i}/{total}] blaming {path:?}: process                       \r");
+                report_info.process_line_coverage_online(&sess);
+                print!("[{i}/{total}] blaming {path:?}: blame                         \r");
                 blame(&report_info, &path.to_string_lossy(), &mut res);
             }
 

src/fuzzer/mod.rs

@@ -29,6 +29,9 @@ pub(crate) fn fuzz(mod_spec: Arc<ModuleSpec>, opts: orc::CliOpts) {
         .unwrap_or_else(|| std::thread::available_parallelism().unwrap().get());
 
     let start = std::time::Instant::now();
+    if let Some(corpus_dir) = opts.g.corpus_dir() {
+        let _ = std::fs::create_dir(corpus_dir);
+    }
 
     let orc_handle = OrchestratorHandle::new(mod_spec.clone(), opts.clone());