buffer refactor from im vector

Swap im::Vector for plain Vec with checkpoint deltas.

Author: philocalyst

asyncgit/src/graph/buffer.rs

@@ -1,24 +1,47 @@
 use super::chunk::{Chunk, Markers};
-use im::Vector;
 use std::collections::BTreeMap;
 
+/// A single mutation of the lane state, recorded while processing one
+/// commit.
 #[derive(Clone, Debug)]
 pub enum DeltaOp {
 	Insert { index: usize, item: Option<Chunk> },
 	Remove { index: usize },
 	Replace { index: usize, new: Option<Chunk> },
 }
 
+/// All lane-state mutations caused by processing a single commit.
+/// Applying a `Delta` to the lane state of row `n` yields the lane
+/// state of row `n + 1`.
 #[derive(Clone, Debug)]
 pub struct Delta(pub Vec<DeltaOp>);
 
 const CHECKPOINT_INTERVAL: usize = 100;
 
+/// Delta-compressed history of the graph's lane state.
+///
+/// While walking the log top-down, every commit mutates the set of
+/// active lanes (a `Vec<Option<Chunk>>`, one slot per lane). So, storign a
+/// full copy of that state for each commit is a waste. This
+/// buffer preserves ONLY the latest state PLUS the list of [`Delta`]s that
+/// produced it.
+/// Use [`Buffer::decompress`] to get the complete version.
 pub struct Buffer {
-	pub current: Vector<Option<Chunk>>,
+	/// Lane state after the most recently processed commit.
+	pub current: Vec<Option<Chunk>>,
+
+	/// One [`Delta`] per processed commit, in the order of the walk.
 	pub deltas: Vec<Delta>,
-	pub checkpoints: BTreeMap<usize, Vector<Option<Chunk>>>,
-	mergers: Vec<usize>,
+
+	/// Full lane-state snapshots taken every `CHECKPOINT_INTERVAL`
+	/// commits, keyed by delta index, for reducing decompression cost.
+	pub checkpoints: BTreeMap<usize, Vec<Option<Chunk>>>,
+
+	/// Aliases of merge commits whose second parent still needs a new
+	/// lane.
+	merge_commits: Vec<usize>,
+
+	/// Scratch list of the [`DeltaOp`]s recorded for processing commit
 	pending_delta: Vec<DeltaOp>,
 }
 
@@ -29,130 +52,162 @@ impl Default for Buffer {
 }
 
 impl Buffer {
-	pub fn new() -> Self {
+	pub const fn new() -> Self {
 		Self {
-			current: Vector::new(),
+			current: Vec::new(),
 			deltas: Vec::new(),
 			checkpoints: BTreeMap::new(),
-			mergers: Vec::new(),
+			merge_commits: Vec::new(),
 			pending_delta: Vec::new(),
 		}
 	}
 
-	pub fn merger(&mut self, alias: usize) {
-		self.mergers.push(alias);
+	/// Remember `alias` as a merge commit whose second parent must be
+	/// given its own lane.
+	pub fn track_merge_commit(&mut self, alias: usize) {
+		self.merge_commits.push(alias);
 	}
 
 	pub fn update(&mut self, new_chunk: &Chunk) {
-		self.pending_delta.clear();
+		// Phase 1: place the new chunk into the lane array.
+		let placement_index = self.place_chunk(new_chunk);
+
+		// Phase 2: consume the alias in all other live chunks.
+		if let Some(alias) = new_chunk.alias {
+			self.consume_alias_in_other_chunks(
+				alias,
+				placement_index,
+			);
+		}
 
-		let mut empty_lanes: Vec<usize> = self
-			.current
-			.iter()
-			.enumerate()
-			.filter_map(|(i, c)| c.is_none().then_some(i))
-			.collect();
+		// Phase 3: flush any pending merge commits into new lanes.
+		self.flush_merge_commits();
 
-		// sort descending so we can pop the lowest index first
-		empty_lanes.sort_unstable_by(|a, b| b.cmp(a));
+		// Phase 4: commit the delta and maybe checkpoint.
+		self.commit_delta();
+	}
 
-		let found_idx = if new_chunk.alias.is_some() {
-			self.current.iter().enumerate().find_map(|(i, c)| {
-				c.as_ref().and_then(|c| {
-					(c.parent_a == new_chunk.alias).then_some(i)
-				})
-			})
-		} else {
-			None
-		};
+	fn place_chunk(&mut self, new_chunk: &Chunk) -> usize {
+		// Prefer a lane whose current occupant is waiting for this chunk as parent_a.
+		let target = self
+			.find_lane_awaiting_parent(new_chunk.alias)
+			.or_else(|| self.first_empty_lane())
+			.unwrap_or(self.current.len());
 
-		if let Some(idx) = found_idx {
-			self.record_replace(idx, Some(new_chunk.clone()));
-		} else if let Some(empty_idx) = empty_lanes.pop() {
-			self.record_replace(empty_idx, Some(new_chunk.clone()));
+		if target < self.current.len() {
+			self.record_replace(target, Some(new_chunk.clone()));
 		} else {
-			self.record_insert(
-				self.current.len(),
-				Some(new_chunk.clone()),
-			);
+			self.record_insert(target, Some(new_chunk.clone()));
 		}
+		target
+	}
 
-		let current_length = self.current.len();
-		for index in 0..current_length {
-			if Some(index) == found_idx {
-				continue;
-			}
-			if found_idx.is_none() && index == current_length - 1 {
-				continue;
-			}
+	fn find_lane_awaiting_parent(
+		&self,
+		alias: Option<usize>,
+	) -> Option<usize> {
+		let alias = alias?;
+		self.current.iter().position(|slot| {
+			slot.as_ref()
+				.is_some_and(|chunk| chunk.parent_a == Some(alias))
+		})
+	}
+
+	fn first_empty_lane(&self) -> Option<usize> {
+		self.current.iter().position(Option::is_none)
+	}
 
-			if let Some(mut c) = self.current[index].clone() {
-				let changed = new_chunk.alias.is_some_and(|alias| {
-					let a = c.parent_a == Some(alias);
-					let b = c.parent_b == Some(alias);
-					if a {
-						c.parent_a = None;
-					}
-					if b {
-						c.parent_b = None;
-					}
-					a || b
-				});
-
-				if changed {
-					if c.parent_a.is_none() && c.parent_b.is_none() {
-						self.record_replace(index, None);
-					} else {
-						self.record_replace(index, Some(c));
-					}
+	fn consume_alias_in_other_chunks(
+		&mut self,
+		alias: usize,
+		skip_index: usize,
+	) {
+		for index in 0..self.current.len() {
+			let mut chunk = match self.current[index].clone() {
+				Some(chunk) if index != skip_index => chunk,
+				_ => continue,
+			};
+
+			let changed_a = chunk.parent_a == Some(alias);
+			let changed_b = chunk.parent_b == Some(alias);
+
+			if changed_a || changed_b {
+				if changed_a {
+					chunk.parent_a = None;
+				}
+				if changed_b {
+					chunk.parent_b = None;
 				}
+
+				self.record_replace(
+					index,
+					chunk.parent_a.is_some().then_some(chunk),
+				);
 			}
 		}
+	}
 
-		while let Some(alias) = self.mergers.pop() {
-			if let Some(index) = self.current.iter().position(|c| {
-				c.as_ref()
-					.is_some_and(|chunk| chunk.alias == Some(alias))
-			}) {
-				if let Some(mut c) = self.current[index].clone() {
-					let parent_b = c.parent_b;
-					c.parent_b = None;
-					self.record_replace(index, Some(c));
-
-					let new_lane = Chunk {
-						alias: None,
-						parent_a: parent_b,
-						parent_b: None,
-						marker: Markers::Commit,
-					};
-
-					if let Some(empty_idx) = empty_lanes.pop() {
-						self.record_replace(
-							empty_idx,
-							Some(new_lane),
-						);
-					} else {
-						self.record_insert(
-							self.current.len(),
-							Some(new_lane),
-						);
-					}
+	fn flush_merge_commits(&mut self) {
+		// Collect available empty lanes once, before we start maybe filling them.
+		let mut empty_lanes: Vec<usize> = self
+			.current
+			.iter()
+			.enumerate()
+			.filter_map(|(index, slot)| {
+				slot.is_none().then_some(index)
+			})
+			.collect();
+
+		while let Some(alias) = self.merge_commits.pop() {
+			// Search for an occupied slot that matches the target alias.
+			// If found, extract its index and a mutable clone of the chunk.
+			let Some((index, mut chunk)) =
+				self.current.iter().enumerate().find_map(
+					|(index, slot)| {
+						let chunk = slot.as_ref()?;
+						(chunk.alias == Some(alias))
+							.then(|| (index, chunk.clone()))
+					},
+				)
+			else {
+				continue;
+			};
+
+			let detached_parent = chunk.parent_b.take();
+			self.record_replace(index, Some(chunk));
+
+			if let Some(parent) = detached_parent {
+				let new_lane = Chunk {
+					alias: None,
+					parent_a: Some(parent),
+					parent_b: None,
+					marker: Markers::Commit,
+				};
+
+				if let Some(empty_index) = empty_lanes.pop() {
+					self.record_replace(empty_index, Some(new_lane));
+				} else {
+					self.record_insert(
+						self.current.len(),
+						Some(new_lane),
+					);
 				}
 			}
 		}
+	}
 
-		while self.current.last().is_some_and(Option::is_none) {
-			self.record_remove(self.current.len() - 1);
+	fn commit_delta(&mut self) {
+		while matches!(self.current.last(), Some(None)) {
+			let last = self.current.len() - 1;
+			self.record_remove(last);
 		}
 
-		let delta = Delta(self.pending_delta.clone());
-		self.deltas.push(delta);
+		self.deltas
+			.push(Delta(std::mem::take(&mut self.pending_delta)));
 
-		let current_step = self.deltas.len();
-		if current_step > 0 && current_step % CHECKPOINT_INTERVAL == 0
-		{
-			self.checkpoints
-				.insert(current_step - 1, self.current.clone());
+		let step = self.deltas.len();
+		if step % CHECKPOINT_INTERVAL == 0 {
+			self.checkpoints.insert(step - 1, self.current.clone());
 		}
 	}
 
@@ -161,7 +216,7 @@ impl Buffer {
 			index,
 			new: new.clone(),
 		});
-		self.current.set(index, new);
+		self.current[index] = new;
 	}
 
 	fn record_insert(&mut self, index: usize, item: Option<Chunk>) {
@@ -181,10 +236,10 @@ impl Buffer {
 		&self,
 		start: usize,
 		end: usize,
-	) -> Vec<Vector<Option<Chunk>>> {
+	) -> Vec<Vec<Option<Chunk>>> {
 		let (current_index, mut state) =
 			self.checkpoints.range(..=start).next_back().map_or_else(
-				|| (None, Vector::new()),
+				|| (None, Vec::new()),
 				|(&i, s)| (Some(i), s.clone()),
 			);
 
@@ -215,7 +270,7 @@ impl Buffer {
 	}
 
 	fn apply_delta_to_state(
-		state: &mut Vector<Option<Chunk>>,
+		state: &mut Vec<Option<Chunk>>,
 		delta: &Delta,
 	) {
 		for op in &delta.0 {
@@ -227,7 +282,7 @@ impl Buffer {
 					state.remove(*index);
 				}
 				DeltaOp::Replace { index, new } => {
-					state.set(*index, new.clone());
+					state[*index].clone_from(new);
 				}
 			}
 		}