This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11096

dirstate-v2: Reuse existing paths when appending to a data file
ClosedPublic

Authored by SimonSapin on Jul 15 2021, 11:28 AM.

Details

Reviewers
marmoute
Alphare
Group Reviewers
hg-reviewers
Commits
rHGa8b0f29dc0d7: dirstate-v2: Reuse existing paths when appending to a data file
Summary

When writing a dirstate in v2 format by appending to an existing data file,
filenames / paths that are borrowed from the previous on-disk representation
can be reused.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Jul 15 2021, 11:28 AM
baymax updated this revision to Diff 29321.Jul 16 2021, 5:38 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute accepted this revision.Jul 16 2021, 6:16 AM
marmoute added a subscriber: marmoute.
marmoute added inline comments.
rust/hg-core/src/dirstate_tree/on_disk.rs
593

looks like this comment want to be in the previous commit.

SimonSapin updated this revision to Diff 29336.Jul 16 2021, 8:37 AM
Alphare accepted this revision.Jul 16 2021, 8:59 AM
This revision is now accepted and ready to land.Jul 16 2021, 8:59 AM
baymax updated this revision to Diff 29353.Jul 16 2021, 5:45 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 29612.Jul 20 2021, 3:41 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 29612

rust/hg-core/src/dirstate_tree/on_disk.rs

out: Vec<u8>, out: Vec<u8>,
} }
impl Writer<'_, '_> { impl Writer<'_, '_> {
fn write_nodes( fn write_nodes(
&mut self, &mut self,
nodes: dirstate_map::ChildNodesRef, nodes: dirstate_map::ChildNodesRef,
) -> Result<ChildNodes, DirstateError> { ) -> Result<ChildNodes, DirstateError> {
// Reuse already-written nodes if possible // Reuse already-written nodes if possible
marmouteUnsubmitted
Not Done

looks like this comment want to be in the previous commit.

marmoute: looks like this comment want to be in the previous commit.
if self.append { if self.append {
if let dirstate_map::ChildNodesRef::OnDisk(nodes_slice) = nodes { if let dirstate_map::ChildNodesRef::OnDisk(nodes_slice) = nodes {
let start = self.offset_of(nodes_slice); let start = self.on_disk_offset_of(nodes_slice).expect(
"dirstate-v2 OnDisk nodes not found within on_disk",
);
let len = child_nodes_len_from_usize(nodes_slice.len()); let len = child_nodes_len_from_usize(nodes_slice.len());
return Ok(ChildNodes { start, len }); return Ok(ChildNodes { start, len });
} }
} }
// `dirstate_map::ChildNodes::InMemory` contains a `HashMap` which has // `dirstate_map::ChildNodes::InMemory` contains a `HashMap` which has
// undefined iteration order. Sort to enable binary search in the // undefined iteration order. Sort to enable binary search in the
// written file. // written file.
// … so we can write them contiguously, after writing everything else // … so we can write them contiguously, after writing everything else
// they refer to. // they refer to.
let start = self.current_offset(); let start = self.current_offset();
let len = child_nodes_len_from_usize(nodes_len); let len = child_nodes_len_from_usize(nodes_len);
self.out.extend(on_disk_nodes.as_bytes()); self.out.extend(on_disk_nodes.as_bytes());
Ok(ChildNodes { start, len }) Ok(ChildNodes { start, len })
} }
/// Takes a slice of items within `on_disk` and returns its offset for the /// If the given slice of items is within `on_disk`, returns its offset
/// start of `on_disk`. /// from the start of `on_disk`.
/// fn on_disk_offset_of<T>(&self, slice: &[T]) -> Option<Offset>
/// Panics if the given slice is not within `on_disk`.
fn offset_of<T>(&self, slice: &[T]) -> Offset
where where
T: BytesCast, T: BytesCast,
{ {
fn address_range(slice: &[u8]) -> std::ops::RangeInclusive<usize> { fn address_range(slice: &[u8]) -> std::ops::RangeInclusive<usize> {
let start = slice.as_ptr() as usize; let start = slice.as_ptr() as usize;
let end = start + slice.len(); let end = start + slice.len();
start..=end start..=end
} }
let slice_addresses = address_range(slice.as_bytes()); let slice_addresses = address_range(slice.as_bytes());
let on_disk_addresses = address_range(self.dirstate_map.on_disk); let on_disk_addresses = address_range(self.dirstate_map.on_disk);
assert!(on_disk_addresses.contains(slice_addresses.start())); if on_disk_addresses.contains(slice_addresses.start())
assert!(on_disk_addresses.contains(slice_addresses.end())); && on_disk_addresses.contains(slice_addresses.end())
{
let offset = slice_addresses.start() - on_disk_addresses.start(); let offset = slice_addresses.start() - on_disk_addresses.start();
offset_from_usize(offset) Some(offset_from_usize(offset))
} else {
None
}
} }
fn current_offset(&mut self) -> Offset { fn current_offset(&mut self) -> Offset {
let mut offset = self.out.len(); let mut offset = self.out.len();
if self.append { if self.append {
offset += self.dirstate_map.on_disk.len() offset += self.dirstate_map.on_disk.len()
} }
offset_from_usize(offset) offset_from_usize(offset)
} }
fn write_path(&mut self, slice: &[u8]) -> PathSlice { fn write_path(&mut self, slice: &[u8]) -> PathSlice {
let start = self.current_offset();
let len = path_len_from_usize(slice.len()); let len = path_len_from_usize(slice.len());
// Reuse an already-written path if possible
if self.append {
if let Some(start) = self.on_disk_offset_of(slice) {
return PathSlice { start, len };
}
}
let start = self.current_offset();
self.out.extend(slice.as_bytes()); self.out.extend(slice.as_bytes());
PathSlice { start, len } PathSlice { start, len }
} }
} }
fn offset_from_usize(x: usize) -> Offset { fn offset_from_usize(x: usize) -> Offset {
u32::try_from(x) u32::try_from(x)
// Could only panic for a dirstate file larger than 4 GiB // Could only panic for a dirstate file larger than 4 GiB