tmp: use polonius loan scopes to see how terribly slow it is

Author: lqd

compiler/rustc_borrowck/src/dataflow.rs

@@ -131,104 +131,6 @@ struct StackEntry {
     lo: usize,
     hi: usize,
 }
-
-struct OutOfScopePrecomputer<'a, 'tcx> {
-    visited: BitSet<mir::BasicBlock>,
-    visit_stack: Vec<StackEntry>,
-    body: &'a Body<'tcx>,
-    regioncx: &'a RegionInferenceContext<'tcx>,
-    borrows_out_of_scope_at_location: FxIndexMap<Location, Vec<BorrowIndex>>,
-}
-
-impl<'a, 'tcx> OutOfScopePrecomputer<'a, 'tcx> {
-    fn new(body: &'a Body<'tcx>, regioncx: &'a RegionInferenceContext<'tcx>) -> Self {
-        OutOfScopePrecomputer {
-            visited: BitSet::new_empty(body.basic_blocks.len()),
-            visit_stack: vec![],
-            body,
-            regioncx,
-            borrows_out_of_scope_at_location: FxIndexMap::default(),
-        }
-    }
-}
-
-impl<'tcx> OutOfScopePrecomputer<'_, 'tcx> {
-    fn precompute_borrows_out_of_scope(
-        &mut self,
-        borrow_index: BorrowIndex,
-        borrow_region: RegionVid,
-        first_location: Location,
-    ) {
-        // We visit one BB at a time. The complication is that we may start in the
-        // middle of the first BB visited (the one containing `first_location`), in which
-        // case we may have to later on process the first part of that BB if there
-        // is a path back to its start.
-
-        // For visited BBs, we record the index of the first statement processed.
-        // (In fully processed BBs this index is 0.) Note also that we add BBs to
-        // `visited` once they are added to `stack`, before they are actually
-        // processed, because this avoids the need to look them up again on
-        // completion.
-        self.visited.insert(first_location.block);
-
-        let first_block = first_location.block;
-        let mut first_lo = first_location.statement_index;
-        let first_hi = self.body[first_block].statements.len();
-
-        self.visit_stack.push(StackEntry { bb: first_block, lo: first_lo, hi: first_hi });
-
-        'preorder: while let Some(StackEntry { bb, lo, hi }) = self.visit_stack.pop() {
-            if let Some(kill_stmt) =
-                self.regioncx.first_non_contained_inclusive(borrow_region, bb, lo, hi)
-            {
-                let kill_location = Location { block: bb, statement_index: kill_stmt };
-                // If region does not contain a point at the location, then add to list and skip
-                // successor locations.
-                debug!("borrow {:?} gets killed at {:?}", borrow_index, kill_location);
-                self.borrows_out_of_scope_at_location
-                    .entry(kill_location)
-                    .or_default()
-                    .push(borrow_index);
-                continue 'preorder;
-            }
-
-            // If we process the first part of the first basic block (i.e. we encounter that block
-            // for the second time), we no longer have to visit its successors again.
-            if bb == first_block && hi != first_hi {
-                continue;
-            }
-
-            // Add successor BBs to the work list, if necessary.
-            let bb_data = &self.body[bb];
-            debug_assert!(hi == bb_data.statements.len());
-            for succ_bb in bb_data.terminator().successors() {
-                if !self.visited.insert(succ_bb) {
-                    if succ_bb == first_block && first_lo > 0 {
-                        // `succ_bb` has been seen before. If it wasn't
-                        // fully processed, add its first part to `stack`
-                        // for processing.
-                        self.visit_stack.push(StackEntry { bb: succ_bb, lo: 0, hi: first_lo - 1 });
-
-                        // And update this entry with 0, to represent the
-                        // whole BB being processed.
-                        first_lo = 0;
-                    }
-                } else {
-                    // succ_bb hasn't been seen before. Add it to
-                    // `stack` for processing.
-                    self.visit_stack.push(StackEntry {
-                        bb: succ_bb,
-                        lo: 0,
-                        hi: self.body[succ_bb].statements.len(),
-                    });
-                }
-            }
-        }
-
-        self.visited.clear();
-    }
-}
-
 struct PoloniusOutOfScopePrecomputer<'a, 'tcx> {
     visited: BitSet<mir::BasicBlock>,
     visit_stack: Vec<StackEntry>,
@@ -455,31 +357,15 @@ pub fn calculate_borrows_out_of_scope_at_location<'tcx>(
     regioncx: &RegionInferenceContext<'tcx>,
     borrow_set: &BorrowSet<'tcx>,
 ) -> FxIndexMap<Location, Vec<BorrowIndex>> {
-    let mut prec = OutOfScopePrecomputer::new(body, regioncx);
-    for (borrow_index, borrow_data) in borrow_set.iter_enumerated() {
-        let borrow_region = borrow_data.region;
-        let location = borrow_data.reserve_location;
+    let mut polonius_prec = PoloniusOutOfScopePrecomputer::new(body, regioncx);
+    for (loan_idx, borrow_data) in borrow_set.iter_enumerated() {
+        let issuing_region = borrow_data.region;
+        let issued_location = borrow_data.reserve_location;
 
-        prec.precompute_borrows_out_of_scope(borrow_index, borrow_region, location);
+        polonius_prec.precompute_loans_out_of_scope(loan_idx, issuing_region, issued_location);
     }
 
-    if std::env::var("POLONIUS2").is_ok() {
-        let mut polonius_prec = PoloniusOutOfScopePrecomputer::new(body, regioncx);
-        for (loan_idx, borrow_data) in borrow_set.iter_enumerated() {
-            let issuing_region = borrow_data.region;
-            let issued_location = borrow_data.reserve_location;
-
-            polonius_prec.precompute_loans_out_of_scope(loan_idx, issuing_region, issued_location);
-        }
-
-        assert_eq!(
-            prec.borrows_out_of_scope_at_location, polonius_prec.borrows_out_of_scope_at_location,
-            "out of scope borrows and loans differ between polonius and non-polonius mode"
-        );
-        polonius_prec.borrows_out_of_scope_at_location
-    } else {
-        prec.borrows_out_of_scope_at_location
-    }
+    polonius_prec.borrows_out_of_scope_at_location
 }
 
 impl<'a, 'tcx> Borrows<'a, 'tcx> {

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -12,7 +12,7 @@ use rustc_infer::infer::outlives::test_type_match;
 use rustc_infer::infer::region_constraints::{GenericKind, VarInfos, VerifyBound, VerifyIfEq};
 use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin};
 use rustc_middle::mir::{
-    BasicBlock, Body, ClosureOutlivesRequirement, ClosureOutlivesSubject, ClosureOutlivesSubjectTy,
+    Body, ClosureOutlivesRequirement, ClosureOutlivesSubject, ClosureOutlivesSubjectTy,
     ClosureRegionRequirements, ConstraintCategory, Local, Location, ReturnConstraint,
     TerminatorKind,
 };
@@ -603,19 +603,19 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         self.scc_values.contains(scc, p)
     }
 
-    /// Returns the lowest statement index in `start..=end` which is not contained by `r`.
-    ///
-    /// Panics if called before `solve()` executes.
-    pub(crate) fn first_non_contained_inclusive(
-        &self,
-        r: RegionVid,
-        block: BasicBlock,
-        start: usize,
-        end: usize,
-    ) -> Option<usize> {
-        let scc = self.constraint_sccs.scc(r);
-        self.scc_values.first_non_contained_inclusive(scc, block, start, end)
-    }
+    // /// Returns the lowest statement index in `start..=end` which is not contained by `r`.
+    // ///
+    // /// Panics if called before `solve()` executes.
+    // pub(crate) fn first_non_contained_inclusive(
+    //     &self,
+    //     r: RegionVid,
+    //     block: BasicBlock,
+    //     start: usize,
+    //     end: usize,
+    // ) -> Option<usize> {
+    //     let scc = self.constraint_sccs.scc(r);
+    //     self.scc_values.first_non_contained_inclusive(scc, block, start, end)
+    // }
 
     /// Returns access to the value of `r` for debugging purposes.
     pub(crate) fn region_value_str(&self, r: RegionVid) -> String {

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -288,21 +288,21 @@ impl<N: Idx> RegionValues<N> {
         elem.contained_in_row(self, r)
     }
 
-    /// Returns the lowest statement index in `start..=end` which is not contained by `r`.
-    pub(crate) fn first_non_contained_inclusive(
-        &self,
-        r: N,
-        block: BasicBlock,
-        start: usize,
-        end: usize,
-    ) -> Option<usize> {
-        let row = self.points.row(r)?;
-        let block = self.elements.entry_point(block);
-        let start = block.plus(start);
-        let end = block.plus(end);
-        let first_unset = row.first_unset_in(start..=end)?;
-        Some(first_unset.index() - block.index())
-    }
+    // /// Returns the lowest statement index in `start..=end` which is not contained by `r`.
+    // pub(crate) fn first_non_contained_inclusive(
+    //     &self,
+    //     r: N,
+    //     block: BasicBlock,
+    //     start: usize,
+    //     end: usize,
+    // ) -> Option<usize> {
+    //     let row = self.points.row(r)?;
+    //     let block = self.elements.entry_point(block);
+    //     let start = block.plus(start);
+    //     let end = block.plus(end);
+    //     let first_unset = row.first_unset_in(start..=end)?;
+    //     Some(first_unset.index() - block.index())
+    // }
 
     /// `self[to] |= values[from]`, essentially: that is, take all the
     /// elements for the region `from` from `values` and add them to