feat: A PriorityQueue that is useful for graph traversal.

Sebastian Thiel committed 3 years ago

Commit dde8c3a1 parent fc423e43 files · +82 −14Browse files

Unified · Split

3 files

gix-revision/src/describe.rs +14 −14
gix-revision/src/lib.rs +8 −0
gix-revision/src/queue.rs +60 −0

 }
 pub(crate) mod function {
-    use std::{borrow::Cow, cmp::Ordering, collections::VecDeque, iter::FromIterator};
+    use std::{borrow::Cow, cmp::Ordering};
     use bstr::BStr;
     use gix_hash::oid;
     use gix_object::CommitRefIter;
     use super::{Error, Outcome};
-    use crate::describe::{Flags, Options, MAX_CANDIDATES};
+    use crate::describe::{CommitTime, Flags, Options, MAX_CANDIDATES};
+    use crate::PriorityQueue;
     /// Given a `commit` id, traverse the commit graph and collect candidate names from the `name_by_oid` mapping to produce
     /// an `Outcome`, which converted [`into_format()`][Outcome::into_format()] will produce a typical `git describe` string.
         let mut buf = Vec::new();
         let mut parent_buf = Vec::new();
-        let mut queue = VecDeque::from_iter(Some((commit.to_owned(), u32::MAX)));
+        let mut queue = PriorityQueue::from_iter(Some((u32::MAX, commit.to_owned())));
         let mut candidates = Vec::new();
         let mut commits_seen = 0;
         let mut gave_up_on_commit = None;
         let mut seen = HashMap::<gix_hash::ObjectId, Flags>::default();
         seen.insert(commit.to_owned(), 0u32);
-        while let Some((commit, _commit_time)) = queue.pop_front() {
+        while let Some(commit) = queue.pop() {
             commits_seen += 1;
             if let Some(name) = name_by_oid.get(&commit) {
                 if candidates.len() < max_candidates {
         });
         if let Some(commit_id) = gave_up_on_commit {
-            queue.push_front((commit_id, u32::MAX));
+            queue.insert(u32::MAX, commit_id);
             commits_seen -= 1;
         }
         find: &mut Find,
         buf: &mut Vec<u8>,
         parent_buf: &mut Vec<u8>,
-        queue: &mut VecDeque<(gix_hash::ObjectId, u32)>,
+        queue: &mut PriorityQueue<CommitTime, gix_hash::ObjectId>,
         seen: &mut HashMap<gix_hash::ObjectId, Flags>,
         commit: &gix_hash::oid,
         commit_flags: Flags,
                             .unwrap_or_default();
                         entry.insert(commit_flags);
-                        match queue.binary_search_by(|c| c.1.cmp(&parent_commit_date).reverse()) {
+                        queue.insert(parent_commit_date, parent_id);
-                            Ok(_) => queue.push_back((parent_id, parent_commit_date)),
-                            Err(pos) => queue.insert(pos, (parent_id, parent_commit_date)),
-                        };
                     }
                     hash_map::Entry::Occupied(mut entry) => {
                         *entry.get_mut() |= commit_flags;
     #[allow(clippy::too_many_arguments)]
     fn finish_depth_computation<'name, Find, E>(
-        mut queue: VecDeque<(gix_hash::ObjectId, u32)>,
+        mut queue: PriorityQueue<CommitTime, gix_hash::ObjectId>,
         mut find: Find,
         best_candidate: &mut Candidate<'name>,
         mut seen: HashMap<gix_hash::ObjectId, Flags>,
         E: std::error::Error + Send + Sync + 'static,
     {
         let mut commits_seen = 0;
-        while let Some((commit, _commit_time)) = queue.pop_front() {
+        while let Some(commit) = queue.pop() {
             commits_seen += 1;
             let flags = seen[&commit];
             if (flags & best_candidate.identity_bit) == best_candidate.identity_bit {
                 if queue
-                    .iter()
+                    .iter_random()
-                    .all(|(id, _)| (seen[id] & best_candidate.identity_bit) == best_candidate.identity_bit)
+                    .all(|id| (seen[id] & best_candidate.identity_bit) == best_candidate.identity_bit)
                 {
                     break;
                 }
         order: usize,
     }
 }
+type CommitTime = u32;

gix-revision/src/lib.rs+8−0

@@ -17,3 +17,11 @@ pub mod spec; · 16 unmodified lines
17		17
18	mod types;	18	mod types;
19	pub use types::Spec;	19	pub use types::Spec;
		20
		21	/// A utility type implementing a queue which can be used to automatically sort data by its time in ascending order.
		22	///
		23	/// Note that the performance of this queue is very relevant to overall algorithm performance of many graph-walking algorithms,
		24	/// and as it stands our implementation is about 6% slower in practice, probably also depending on the size of the stored data.
		25	#[derive(Default)]
		26	pub struct PriorityQueue<K: Ord, T>(std::collections::BinaryHeap<queue::Item<K, T>>);
		27	mod queue;

gix-revision/src/queue.rs+60−0

@@ -0,0 +1,60 @@
	1	use crate::PriorityQueue;
	2	use std::cmp::Ordering;
	3	use std::collections::BinaryHeap;
	4
	5	pub(crate) struct Item<K, T> {
	6	key: K,
	7	value: T,
	8	}
	9
	10	impl<K: Ord, T> PartialEq<Self> for Item<K, T> {
	11	fn eq(&self, other: &Self) -> bool {
	12	Ord::cmp(self, other).is_eq()
	13	}
	14	}
	15
	16	impl<K: Ord, T> Eq for Item<K, T> {}
	17
	18	impl<K: Ord, T> PartialOrd<Self> for Item<K, T> {
	19	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
	20	Ord::cmp(self, other).into()
	21	}
	22	}
	23
	24	impl<K: Ord, T> Ord for Item<K, T> {
	25	fn cmp(&self, other: &Self) -> Ordering {
	26	self.key.cmp(&other.key)
	27	}
	28	}
	29
	30	impl<K: Ord, T> PriorityQueue<K, T> {
	31	/// Insert `value` so that it is ordered according to `key`.
	32	pub fn insert(&mut self, key: K, value: T) {
	33	self.0.push(Item { key, value });
	34	}
	35
	36	/// Pop the highest-priority item off the queue.
	37	pub fn pop(&mut self) -> Option<T> {
	38	self.0.pop().map(\|t\| t.value)
	39	}
	40
	41	/// Iterate all items ordered from highest to lowest priority.
	42	pub fn iter_random(&self) -> impl Iterator<Item = &T> {
	43	self.0.iter().map(\|t\| &t.value)
	44	}
	45
	46	/// Return true if the queue is empty.
	47	pub fn is_empty(&self) -> bool {
	48	self.0.is_empty()
	49	}
	50	}
	51
	52	impl<K: Ord, T> FromIterator<(K, T)> for PriorityQueue<K, T> {
	53	fn from_iter<I: IntoIterator<Item = (K, T)>>(iter: I) -> Self {
	54	let mut q = PriorityQueue(BinaryHeap::new());
	55	for (k, v) in iter {
	56	q.insert(k, v);
	57	}
	58	q
	59	}
	60	}