Track outdated priorities in a set

Author: konstin

src/internal/partial_solution.rs

@@ -73,9 +73,9 @@ pub struct PartialSolution<DP: DependencyProvider> {
     #[allow(clippy::type_complexity)]
     prioritized_potential_packages:
         PriorityQueue<Id<DP::P>, (DP::Priority, Reverse<u32>), BuildHasherDefault<FxHasher>>,
-    /// Contains all packages that **have** had there assignments changed since
-    /// the last time `prioritize` has been called on them.
-    unprioritized_potential_packages: FnvIndexSet<Id<DP::P>>,
+    /// Packages whose derivations changed since the last time `prioritize` was called and need
+    /// their priorities to be updated.
+    outdated_priorities: FnvIndexSet<Id<DP::P>>,
     /// Whether we have never backtracked, to enable fast path optimizations.
     has_ever_backtracked: bool,
 }
@@ -183,7 +183,7 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
             current_decision_level: DecisionLevel(0),
             package_assignments: FnvIndexMap::default(),
             prioritized_potential_packages: PriorityQueue::default(),
-            unprioritized_potential_packages: FnvIndexSet::default(),
+            outdated_priorities: FnvIndexSet::default(),
             has_ever_backtracked: false,
         }
     }
@@ -299,7 +299,7 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
                         *t = t.intersection(&dated_derivation.accumulated_intersection);
                         dated_derivation.accumulated_intersection = t.clone();
                         if t.is_positive() {
-                            self.unprioritized_potential_packages.insert(package);
+                            self.outdated_priorities.insert(package);
                         }
                     }
                 }
@@ -308,7 +308,7 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
             Entry::Vacant(v) => {
                 let term = dated_derivation.accumulated_intersection.clone();
                 if term.is_positive() {
-                    self.unprioritized_potential_packages.insert(package);
+                    self.outdated_priorities.insert(package);
                 }
                 v.insert(PackageAssignments {
                     smallest_decision_level: self.current_decision_level,
@@ -327,6 +327,12 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
             .get_range(current_decision_level.0 as usize..)
             .unwrap()
             .iter()
+            .filter(move |(_, pa)| {
+                // We only actually need to update the package if it was changed
+                // since the last time we called prioritize, which means it's highest decision level
+                // is the current decision level, or if we backtracked in the meantime.
+                pa.highest_decision_level == current_decision_level
+            })
             .filter_map(|(&p, pa)| {
                 Some((p, pa.assignments_intersection.potential_package_filter()?))
             })
@@ -338,7 +344,7 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
         mut prioritizer: impl FnMut(Id<DP::P>, &DP::VS) -> DP::Priority,
     ) -> Option<Id<DP::P>> {
         let prioritized_potential_packages = &mut self.prioritized_potential_packages;
-        while let Some(p) = self.unprioritized_potential_packages.pop() {
+        while let Some(p) = self.outdated_priorities.pop() {
             let Some(pa) = self.package_assignments.get(&p) else {
                 continue;
             };
@@ -361,25 +367,6 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
         None
     }
 
-    /// Manually update a package priority that changed independent of the range.
-    pub fn update_priority(&mut self, package: Id<DP::P>, priority: DP::Priority) {
-        if self
-            .package_assignments
-            .get(&package)
-            .and_then(|assignment| {
-                assignment
-                    .assignments_intersection
-                    .potential_package_filter()
-            })
-            .is_none()
-        {
-            // Only prioritize packages up for decision
-            return;
-        }
-        self.prioritized_potential_packages
-            .push(package, (priority, Reverse(package.into_raw() as u32)));
-    }
-
     /// If a partial solution has, for every positive derivation,
     /// a corresponding decision that satisfies that assignment,
     /// it's a total solution and version solving has succeeded.
@@ -429,7 +416,7 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
                     .is_some()
                     && self.prioritized_potential_packages.get(p).is_none()
                 {
-                    self.unprioritized_potential_packages.insert(*p);
+                    self.outdated_priorities.insert(*p);
                 }
                 true
             } else {
@@ -458,7 +445,7 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
 
                 self.prioritized_potential_packages.remove(p);
                 if pa.assignments_intersection.term().is_positive() {
-                    self.unprioritized_potential_packages.insert(*p);
+                    self.outdated_priorities.insert(*p);
                 }
                 true
             }