Initial implementation (#42)

* Initial implementation

* fmt things

* Make pathbuf to be a bit easier

* Move to a predicate

* Add bench for subreport generation

* Update changelog

Author: xd009642

CHANGELOG.md

@@ -5,6 +5,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- Added the ability to filter out certain sections from the generated coverage reports
+
 ### Changed
 - Now use some hashmap based caching to speedup record lookup during profile merge.
 

Cargo.toml

@@ -62,3 +62,8 @@ path = "benches/profdata_parsing.rs"
 name =  "report_merging"
 harness = false
 path = "benches/report_merging.rs"
+
+[[bench]]
+name = "coverage_mapping"
+harness = false
+path = "benches/coverage_mapping.rs"

benches/coverage_mapping.rs

@@ -0,0 +1,83 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use llvm_profparser::*;
+use std::fs;
+
+// This benchmark is a bit faffy as first you need to generate the binaries and profraws and pop
+// them in the appropriate folder structure. After that it will work as expected
+
+pub fn coverage_mapping(c: &mut Criterion) {
+    let files = fs::read_dir("./benches/data/mapping/profraws")
+        .unwrap()
+        .map(|x| x.unwrap().path())
+        .collect::<Vec<_>>();
+
+    let profile = merge_profiles(&files).unwrap();
+
+    let binaries = fs::read_dir("./benches/data/mapping/binaries")
+        .unwrap()
+        .map(|x| x.unwrap().path())
+        .collect::<Vec<_>>();
+
+    c.bench_function("coverage mapping", |b| {
+        b.iter(|| {
+            let _a = CoverageMapping::new(black_box(&binaries), black_box(&profile), true).unwrap();
+        })
+    });
+}
+
+pub fn report_generation(c: &mut Criterion) {
+    let files = fs::read_dir("./benches/data/mapping/profraws")
+        .unwrap()
+        .map(|x| x.unwrap().path())
+        .collect::<Vec<_>>();
+
+    let profile = merge_profiles(&files).unwrap();
+
+    let binaries = fs::read_dir("./benches/data/mapping/binaries")
+        .unwrap()
+        .map(|x| x.unwrap().path())
+        .collect::<Vec<_>>();
+
+    let mapping = CoverageMapping::new(&binaries, &profile, true).unwrap();
+
+    c.bench_function("report generation", |b| {
+        b.iter(|| {
+            let _a = mapping.generate_report();
+        })
+    });
+}
+
+pub fn subreport_generation(c: &mut Criterion) {
+    let files = fs::read_dir("./benches/data/mapping/profraws")
+        .unwrap()
+        .map(|x| x.unwrap().path())
+        .collect::<Vec<_>>();
+
+    let profile = merge_profiles(&files).unwrap();
+
+    let binaries = fs::read_dir("./benches/data/mapping/binaries")
+        .unwrap()
+        .map(|x| x.unwrap().path())
+        .collect::<Vec<_>>();
+
+    let mapping = CoverageMapping::new(&binaries, &profile, true).unwrap();
+
+    c.bench_function("subreport generation", |b| {
+        b.iter(|| {
+            let _a = mapping.generate_subreport(|paths| {
+                paths
+                    .iter()
+                    .any(|path| path.starts_with("/home/daniel/personal/tarpaulin/src"))
+            });
+        })
+    });
+}
+
+criterion_group!(
+    benches,
+    coverage_mapping,
+    report_generation,
+    subreport_generation
+);
+
+criterion_main!(benches);

benches/data/mapping/.gitignore

@@ -0,0 +1,2 @@
+/binaries
+/profraws

src/coverage/coverage_mapping.rs

@@ -9,7 +9,7 @@ use std::convert::TryInto;
 use std::error::Error;
 use std::fmt;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use tracing::{debug, error, trace, warn};
 
 /// Stores the instrumentation profile and information from the coverage mapping sections in the
@@ -149,14 +149,17 @@ impl<'a> CoverageMapping<'a> {
         result
     }
 
-    pub fn generate_report(&self) -> CoverageReport {
+    pub fn generate_subreport<P>(&self, mut predicate: P) -> CoverageReport
+    where
+        P: FnMut(&[PathBuf]) -> bool,
+    {
         let mut report = CoverageReport::default();
         //let base_region_ids = info.get_simple_counters(self.profile);
         for info in &self.mapping_info {
             for func in &info.cov_fun {
                 let base_region_ids = self.get_simple_counters(func);
                 let paths = info.get_files_from_id(func.header.filenames_ref);
-                if paths.is_empty() {
+                if paths.is_empty() || !predicate(&paths) {
                     continue;
                 }
 
@@ -265,6 +268,10 @@ impl<'a> CoverageMapping<'a> {
         }
         report
     }
+
+    pub fn generate_report(&self) -> CoverageReport {
+        self.generate_subreport(|_| true)
+    }
 }
 
 fn parse_coverage_mapping(