From a7a35956687b726f86aa158cb65448fcfd1d6e93 Mon Sep 17 00:00:00 2001 From: Zalathar Date: Wed, 11 Sep 2024 17:16:14 +1000 Subject: [PATCH 1/2] coverage: Separate creation of edge counters from building their sum --- .../src/coverage/counters.rs | 54 +++++++++---------- 1 file changed, 26 insertions(+), 28 deletions(-) diff --git a/compiler/rustc_mir_transform/src/coverage/counters.rs b/compiler/rustc_mir_transform/src/coverage/counters.rs index 1c240366afa2e..fea615138000f 100644 --- a/compiler/rustc_mir_transform/src/coverage/counters.rs +++ b/compiler/rustc_mir_transform/src/coverage/counters.rs @@ -315,20 +315,20 @@ impl<'a> MakeBcbCounters<'a> { // For each out-edge other than the one that was chosen to get an expression, // ensure that it has a counter (existing counter/expression or a new counter), // and accumulate the corresponding counters into a single sum expression. - let sum_of_all_other_out_edges: BcbCounter = { - let _span = debug_span!("sum_of_all_other_out_edges", ?expression_to_bcb).entered(); - successors - .iter() - .copied() - // Skip the chosen edge, since we'll calculate its count from this sum. - .filter(|&to_bcb| to_bcb != expression_to_bcb) - .fold(None, |accum, to_bcb| { - let _span = debug_span!("to_bcb", ?accum, ?to_bcb).entered(); - let edge_counter = self.get_or_make_edge_counter(from_bcb, to_bcb); - Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) - }) - .expect("there must be at least one other out-edge") - }; + let other_out_edge_counters = successors + .iter() + .copied() + // Skip the chosen edge, since we'll calculate its count from this sum. + .filter(|&to_bcb| to_bcb != expression_to_bcb) + .map(|to_bcb| self.get_or_make_edge_counter(from_bcb, to_bcb)) + .collect::>(); + let sum_of_all_other_out_edges: BcbCounter = other_out_edge_counters + .iter() + .copied() + .fold(None, |accum, edge_counter| { + Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) + }) + .expect("there must be at least one other out-edge"); // Now create an expression for the chosen edge, by taking the counter // for its source node and subtracting the sum of its sibling out-edges. @@ -375,20 +375,18 @@ impl<'a> MakeBcbCounters<'a> { // A BCB with multiple incoming edges can compute its count by ensuring that counters // exist for each of those edges, and then adding them up to get a total count. - let sum_of_in_edges: BcbCounter = { - let _span = debug_span!("sum_of_in_edges", ?bcb).entered(); - // We avoid calling `self.bcb_predecessors` here so that we can - // call methods on `&mut self` inside the fold. - self.basic_coverage_blocks.predecessors[bcb] - .iter() - .copied() - .fold(None, |accum, from_bcb| { - let _span = debug_span!("from_bcb", ?accum, ?from_bcb).entered(); - let edge_counter = self.get_or_make_edge_counter(from_bcb, bcb); - Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) - }) - .expect("there must be at least one in-edge") - }; + let in_edge_counters = self.basic_coverage_blocks.predecessors[bcb] + .iter() + .copied() + .map(|from_bcb| self.get_or_make_edge_counter(from_bcb, bcb)) + .collect::>(); + let sum_of_in_edges: BcbCounter = in_edge_counters + .iter() + .copied() + .fold(None, |accum, edge_counter| { + Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) + }) + .expect("there must be at least one in-edge"); debug!("{bcb:?} gets a new counter (sum of predecessor counters): {sum_of_in_edges:?}"); self.coverage_counters.set_bcb_counter(bcb, sum_of_in_edges) From 2344133ba6abfe54e48cafecca2dff53a9484b07 Mon Sep 17 00:00:00 2001 From: Zalathar Date: Wed, 11 Sep 2024 17:24:31 +1000 Subject: [PATCH 2/2] coverage: Simplify creation of sum counters --- .../src/coverage/counters.rs | 30 ++++++++----------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/compiler/rustc_mir_transform/src/coverage/counters.rs b/compiler/rustc_mir_transform/src/coverage/counters.rs index fea615138000f..7e3ecad1bce99 100644 --- a/compiler/rustc_mir_transform/src/coverage/counters.rs +++ b/compiler/rustc_mir_transform/src/coverage/counters.rs @@ -155,12 +155,14 @@ impl CoverageCounters { BcbCounter::Expression { id } } - /// Variant of `make_expression` that makes `lhs` optional and assumes [`Op::Add`]. + /// Creates a counter that is the sum of the given counters. /// - /// This is useful when using [`Iterator::fold`] to build an arbitrary-length sum. - fn make_sum_expression(&mut self, lhs: Option, rhs: BcbCounter) -> BcbCounter { - let Some(lhs) = lhs else { return rhs }; - self.make_expression(lhs, Op::Add, rhs) + /// Returns `None` if the given list of counters was empty. + fn make_sum(&mut self, counters: &[BcbCounter]) -> Option { + counters + .iter() + .copied() + .reduce(|accum, counter| self.make_expression(accum, Op::Add, counter)) } pub(super) fn num_counters(&self) -> usize { @@ -322,12 +324,9 @@ impl<'a> MakeBcbCounters<'a> { .filter(|&to_bcb| to_bcb != expression_to_bcb) .map(|to_bcb| self.get_or_make_edge_counter(from_bcb, to_bcb)) .collect::>(); - let sum_of_all_other_out_edges: BcbCounter = other_out_edge_counters - .iter() - .copied() - .fold(None, |accum, edge_counter| { - Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) - }) + let sum_of_all_other_out_edges: BcbCounter = self + .coverage_counters + .make_sum(&other_out_edge_counters) .expect("there must be at least one other out-edge"); // Now create an expression for the chosen edge, by taking the counter @@ -380,12 +379,9 @@ impl<'a> MakeBcbCounters<'a> { .copied() .map(|from_bcb| self.get_or_make_edge_counter(from_bcb, bcb)) .collect::>(); - let sum_of_in_edges: BcbCounter = in_edge_counters - .iter() - .copied() - .fold(None, |accum, edge_counter| { - Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) - }) + let sum_of_in_edges: BcbCounter = self + .coverage_counters + .make_sum(&in_edge_counters) .expect("there must be at least one in-edge"); debug!("{bcb:?} gets a new counter (sum of predecessor counters): {sum_of_in_edges:?}");