index: in heads_pos(), compare generation when queuing parents

Since heads_pos() visits all ancestors of candidates down to min generation,
traversal order doesn't really matter. We use BinaryHeap just because it's
cheaper than DFS/BFS which would have to maintain a visited set.

```
revsets/heads(tags())
---------------------
1      1.00       4.5±0.08ms
0      1.28       5.8±0.08ms
```

FWIW, is_ancestor_pos() uses DFS, which is fast in happy path, but slow if no
match found.

Author: yuja

lib/src/default_index/composite.rs

@@ -32,7 +32,6 @@ use ref_cast::RefCastCustom;
 
 use super::entry::IndexEntry;
 use super::entry::IndexPosition;
-use super::entry::IndexPositionByGeneration;
 use super::entry::LocalPosition;
 use super::entry::SmallIndexPositionsVec;
 use super::entry::SmallLocalPositionsVec;
@@ -386,36 +385,36 @@ impl CompositeIndex {
         // Add all parents of the candidates to the work queue. The parents and their
         // ancestors are not heads.
         // Also find the smallest generation number among the candidates.
-        let mut work = BinaryHeap::new();
+        let mut work = Vec::new();
         let mut min_generation = u32::MAX;
         for pos in &candidate_positions {
             let entry = self.entry_by_pos(*pos);
             min_generation = min(min_generation, entry.generation_number());
-            for parent_entry in entry.parents() {
-                work.push(IndexPositionByGeneration::from(&parent_entry));
-            }
+            work.extend(entry.parent_positions());
         }
+        let mut work = BinaryHeap::from(work);
 
         // Walk ancestors of the parents of the candidates. Remove visited commits from
         // set of candidates. Stop walking when we have gone past the minimum
         // candidate generation.
-        while let Some(&item) = work.peek() {
-            if item.generation_number() < min_generation {
-                break;
-            }
-            let cur_pos = item.position();
+        while let Some(&cur_pos) = work.peek() {
             candidate_positions.remove(&cur_pos);
-            let mut parent_entries = self.entry_by_pos(cur_pos).parents();
-            if let Some(parent_entry) = parent_entries.next() {
-                assert!(parent_entry.position() < cur_pos);
-                dedup_replace(&mut work, IndexPositionByGeneration::from(&parent_entry)).unwrap();
+            let entry = self.entry_by_pos(cur_pos);
+            if entry.generation_number() <= min_generation {
+                dedup_pop(&mut work).unwrap();
+                continue;
+            }
+            let mut parent_positions = entry.parent_positions().into_iter();
+            if let Some(parent_pos) = parent_positions.next() {
+                assert!(parent_pos < cur_pos);
+                dedup_replace(&mut work, parent_pos).unwrap();
             } else {
                 dedup_pop(&mut work).unwrap();
                 continue;
             }
-            for parent_entry in parent_entries {
-                assert!(parent_entry.position() < cur_pos);
-                work.push(IndexPositionByGeneration::from(&parent_entry));
+            for parent_pos in parent_positions {
+                assert!(parent_pos < cur_pos);
+                work.push(parent_pos);
             }
         }
         candidate_positions

lib/src/default_index/entry.rs

@@ -121,34 +121,3 @@ impl<'a> IndexEntry<'a> {
             .map(move |pos| composite.entry_by_pos(pos))
     }
 }
-
-/// Wrapper to sort `IndexPosition` by its generation number.
-///
-/// This is similar to `IndexEntry` newtypes, but optimized for size and cache
-/// locality. The original `IndexEntry` will have to be looked up when needed.
-#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub(super) struct IndexPositionByGeneration {
-    // Packed to single u64 value for faster comparison
-    value: u64,
-}
-
-impl IndexPositionByGeneration {
-    fn new(IndexPosition(pos): IndexPosition, generation: u32) -> Self {
-        let value = u64::from(generation) << 32 | u64::from(pos);
-        IndexPositionByGeneration { value }
-    }
-
-    pub fn position(&self) -> IndexPosition {
-        IndexPosition(self.value as u32)
-    }
-
-    pub fn generation_number(&self) -> u32 {
-        (self.value >> 32) as u32
-    }
-}
-
-impl From<&IndexEntry<'_>> for IndexPositionByGeneration {
-    fn from(entry: &IndexEntry<'_>) -> Self {
-        Self::new(entry.position(), entry.generation_number())
-    }
-}