parents on demand

Author: philocalyst

asyncgit/src/revlog.rs

@@ -3,7 +3,7 @@ use crate::{
 	graph::{GraphRow, GraphWalker},
 	sync::{
 		gix_repo, repo, CommitId, LogWalker, LogWalkerWithoutFilter,
-		RepoPath, SharedCommitFilterFn, WalkEntry,
+		RepoPath, SharedCommitFilterFn,
 	},
 	AsyncGitNotification, Error,
 };
@@ -47,9 +47,10 @@ pub struct AsyncLog {
 	filter: Option<SharedCommitFilterFn>,
 	partial_extract: AtomicBool,
 	repo: RepoPath,
-	/// All walk entries collected by the background thread, in walk order.
-	/// The graph walker reads these lazily, only as far as the viewport requires.
-	walk_entries: Arc<Mutex<Vec<WalkEntry>>>,
+	/// All commit ids collected by the background thread, in walk order.
+	/// The graph walker reads these lazily, only as far as the viewport
+	/// requires, looking up each commit's parents on demand.
+	walk_entries: Arc<Mutex<Vec<CommitId>>>,
 	graph_walker: Arc<Mutex<GraphWalker>>,
 }
 
@@ -83,8 +84,8 @@ impl AsyncLog {
 
 	/// Computes graph rows for `commit_slice` starting at `global_start`.
 	///
-	/// Driven lazily. Processes only as many
-	/// [`WalkEntry`]s as the viewport requires.
+	/// Driven lazily. Processes only as many walked commits as the
+	/// viewport requires, resolving their parents on demand.
 	///
 	/// Returns `None` when the background walk hasn't reached
 	/// `global_start + commit_slice.len()` yet.
@@ -111,8 +112,18 @@ impl AsyncLog {
 			// we know it is yet to have seen
 			let processed =
 				walker.processed_commits().min(needed_end);
-			for entry in &entries[processed..needed_end] {
-				walker.process(entry.id, &entry.parents);
+
+			// The graph only needs topology for the commits it is
+			// about to fold in, so parents are looked up here on
+			// demand instead of being carried along the whole walk.
+			if processed < needed_end {
+				let mut repo = gix_repo(&self.repo).ok()?;
+				repo.object_cache_size_if_unset(2_usize.pow(14));
+
+				for id in &entries[processed..needed_end] {
+					let parents = Self::parents_of(&repo, *id).ok()?;
+					walker.process(*id, &parents);
+				}
 			}
 		}
 
@@ -125,6 +136,22 @@ impl AsyncLog {
 		))
 	}
 
+	/// Looks up a commit's (up to two) parents on demand.
+	///
+	/// The graph caps support at two parents, ignoring octopus
+	/// merges, so anything beyond the first two is dropped here.
+	fn parents_of(
+		repo: &gix::Repository,
+		id: CommitId,
+	) -> Result<Vec<CommitId>> {
+		Ok(repo
+			.find_commit(id)?
+			.parent_ids()
+			.take(2)
+			.map(Into::into)
+			.collect())
+	}
+
 	///
 	pub fn count(&self) -> Result<usize> {
 		Ok(self.current.lock()?.commits.len())
@@ -252,7 +279,7 @@ impl AsyncLog {
 		arc_current: &Arc<Mutex<AsyncLogResult>>,
 		arc_background: &Arc<AtomicBool>,
 		sender: &Sender<AsyncGitNotification>,
-		arc_walk_entries: &Arc<Mutex<Vec<WalkEntry>>>,
+		arc_walk_entries: &Arc<Mutex<Vec<CommitId>>>,
 		filter: Option<SharedCommitFilterFn>,
 	) -> Result<()> {
 		filter.map_or_else(
@@ -309,7 +336,7 @@ impl AsyncLog {
 		arc_current: &Arc<Mutex<AsyncLogResult>>,
 		arc_background: &Arc<AtomicBool>,
 		sender: &Sender<AsyncGitNotification>,
-		arc_walk_entries: &Arc<Mutex<Vec<WalkEntry>>>,
+		arc_walk_entries: &Arc<Mutex<Vec<CommitId>>>,
 	) -> Result<()> {
 		let mut repo: gix::Repository = gix_repo(repo_path)?;
 		let mut walker =
@@ -332,23 +359,23 @@ impl AsyncLog {
 	/// to `arc_current` and (when given) moving the full entries into
 	/// `walk_entries` for the graph.
 	fn walk_loop(
-		mut read: impl FnMut(&mut Vec<WalkEntry>) -> Result<usize>,
+		mut read: impl FnMut(&mut Vec<CommitId>) -> Result<usize>,
 		arc_current: &Arc<Mutex<AsyncLogResult>>,
 		arc_background: &Arc<AtomicBool>,
 		sender: &Sender<AsyncGitNotification>,
-		walk_entries: Option<&Mutex<Vec<WalkEntry>>>,
+		walk_entries: Option<&Mutex<Vec<CommitId>>>,
 	) -> Result<()> {
 		let start_time = Instant::now();
 
-		let mut entries: Vec<WalkEntry> =
+		let mut entries: Vec<CommitId> =
 			Vec::with_capacity(LIMIT_COUNT);
 
 		loop {
 			let read_count = read(&mut entries)?;
 
 			{
 				let mut current = arc_current.lock()?;
-				current.commits.extend(entries.iter().map(|e| e.id));
+				current.commits.extend(entries.iter().copied());
 				current.duration = start_time.elapsed();
 			}
 

asyncgit/src/sync/logwalker.rs

@@ -2,25 +2,11 @@ use super::{CommitId, SharedCommitFilterFn};
 use crate::error::Result;
 use git2::{Commit, Oid, Repository};
 use gix::revision::Walk;
-use smallvec::SmallVec;
 use std::{
 	cmp::Ordering,
 	collections::{BinaryHeap, HashSet},
 };
 
-/// A commit id together with the ids of its TWO parents.
-///
-/// The parents come for free during a walk.
-/// Collecting here avoid a second, convulted pass.
-#[derive(Debug, Clone)]
-pub struct WalkEntry {
-	/// The commit's own unique identifier.
-	pub id: CommitId,
-
-	/// The commit's parent identifiers.
-	pub parents: SmallVec<[CommitId; 2]>,
-}
-
 struct TimeOrderedCommit<'a>(Commit<'a>);
 
 impl Eq for TimeOrderedCommit<'_> {}
@@ -86,16 +72,12 @@ impl<'a> LogWalker<'a> {
 	///
 	pub fn read(
 		&mut self,
-		out: &mut Vec<WalkEntry>,
+		out: &mut Vec<CommitId>,
 	) -> Result<usize> {
 		let mut count = 0_usize;
 
 		while let Some(c) = self.commits.pop() {
-			let mut parents = SmallVec::new();
 			for p in c.0.parents() {
-				if parents.len() < 2 {
-					parents.push(p.id().into());
-				}
 				self.visit(p);
 			}
 
@@ -108,7 +90,7 @@ impl<'a> LogWalker<'a> {
 				};
 
 			if commit_should_be_included {
-				out.push(WalkEntry { id, parents });
+				out.push(id);
 			}
 
 			count += 1;
@@ -180,20 +162,12 @@ impl<'a> LogWalkerWithoutFilter<'a> {
 	///
 	pub fn read(
 		&mut self,
-		out: &mut Vec<WalkEntry>,
+		out: &mut Vec<CommitId>,
 	) -> Result<usize> {
 		let mut count = 0_usize;
 
 		while let Some(Ok(info)) = self.walk.next() {
-			out.push(WalkEntry {
-				id: info.id.into(),
-				parents: info
-					.parent_ids
-					.iter()
-					.take(2)
-					.map(|id| CommitId::from(*id))
-					.collect(),
-			});
+			out.push(info.id.into());
 
 			count += 1;
 
@@ -246,7 +220,7 @@ mod tests {
 		walk.read(&mut items).unwrap();
 
 		assert_eq!(items.len(), 1);
-		assert_eq!(items[0].id, oid2);
+		assert_eq!(items[0], oid2);
 
 		Ok(())
 	}
@@ -270,12 +244,12 @@ mod tests {
 		let mut walk = LogWalker::new(&repo, 100)?;
 		walk.read(&mut items).unwrap();
 
-		let ids: Vec<CommitId> = items.iter().map(|e| e.id).collect();
+		let ids: Vec<CommitId> = items.clone();
 		let info = get_commits_info(repo_path, &ids, 50).unwrap();
 		dbg!(&info);
 
 		assert_eq!(items.len(), 2);
-		assert_eq!(items[0].id, oid2);
+		assert_eq!(items[0], oid2);
 
 		let mut items = Vec::new();
 		walk.read(&mut items).unwrap();
@@ -305,12 +279,12 @@ mod tests {
 		let mut items = Vec::new();
 		assert!(matches!(walk.read(&mut items), Ok(2)));
 
-		let ids: Vec<CommitId> = items.iter().map(|e| e.id).collect();
+		let ids: Vec<CommitId> = items.clone();
 		let info = get_commits_info(repo_path, &ids, 50).unwrap();
 		dbg!(&info);
 
 		assert_eq!(items.len(), 2);
-		assert_eq!(items[0].id, oid2);
+		assert_eq!(items[0], oid2);
 
 		let mut items = Vec::new();
 		assert!(matches!(walk.read(&mut items), Ok(0)));
@@ -352,7 +326,7 @@ mod tests {
 		walker.read(&mut items).unwrap();
 
 		assert_eq!(items.len(), 1);
-		assert_eq!(items[0].id, second_commit_id);
+		assert_eq!(items[0], second_commit_id);
 
 		let mut items = Vec::new();
 		walker.read(&mut items).unwrap();
@@ -399,7 +373,7 @@ mod tests {
 		walker.read(&mut items).unwrap();
 
 		assert_eq!(items.len(), 1);
-		assert_eq!(items[0].id, second_commit_id);
+		assert_eq!(items[0], second_commit_id);
 
 		let log_filter = filter_commit_by_search(
 			LogFilterSearch::new(LogFilterSearchOptions {

asyncgit/src/sync/mod.rs

@@ -72,7 +72,7 @@ pub use hooks::{
 };
 pub use hunks::{reset_hunk, stage_hunk, unstage_hunk};
 pub use ignore::add_to_ignore;
-pub use logwalker::{LogWalker, LogWalkerWithoutFilter, WalkEntry};
+pub use logwalker::{LogWalker, LogWalkerWithoutFilter};
 pub use merge::{
 	abort_pending_rebase, abort_pending_state,
 	continue_pending_rebase, merge_branch, merge_commit, merge_msg,
@@ -267,7 +267,7 @@ pub mod tests {
 			.read(&mut entries)
 			.unwrap();
 
-		entries.iter().map(|e| e.id).collect()
+		entries
 	}
 
 	/// Same as `repo_init`, but the repo is a bare repo (--bare)