This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10751

dirstate-v2: Parse the dirstate lazily, with copy-on-write nodes
ClosedPublic

Authored by SimonSapin on May 19 2021, 12:37 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG0654b3b3d2b5: dirstate-v2: Parse the dirstate lazily, with copy-on-write nodes
Summary

TODO: more description

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.May 19 2021, 12:37 PM
baymax updated this revision to Diff 28175.May 21 2021, 4:37 AM

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

Alphare accepted this revision.May 21 2021, 5:52 AM
This revision is now accepted and ready to land.May 21 2021, 5:52 AM
baymax updated this revision to Diff 28274.May 30 2021, 3:27 PM

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

Revision Contents
Changeset List

Diff 28286

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

/// map key would also work: all paths in a given map have the same parent /// map key would also work: all paths in a given map have the same parent
/// path, so comparing full paths gives the same result as comparing base /// path, so comparing full paths gives the same result as comparing base
/// names. However `HashMap` would waste time always re-hashing the same /// names. However `HashMap` would waste time always re-hashing the same
/// string prefix. /// string prefix.
pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>; pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;
pub(super) enum ChildNodes<'on_disk> { pub(super) enum ChildNodes<'on_disk> {
InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>), InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
OnDisk(&'on_disk [on_disk::Node]),
} }
pub(super) enum ChildNodesRef<'tree, 'on_disk> { pub(super) enum ChildNodesRef<'tree, 'on_disk> {
InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>), InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
OnDisk(&'on_disk [on_disk::Node]),
} }
pub(super) enum NodeRef<'tree, 'on_disk> { pub(super) enum NodeRef<'tree, 'on_disk> {
InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>), InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>),
OnDisk(&'on_disk on_disk::Node),
} }
impl Default for ChildNodes<'_> { impl Default for ChildNodes<'_> {
fn default() -> Self { fn default() -> Self {
ChildNodes::InMemory(Default::default()) ChildNodes::InMemory(Default::default())
} }
} }
impl<'on_disk> ChildNodes<'on_disk> { impl<'on_disk> ChildNodes<'on_disk> {
pub(super) fn as_ref<'tree>( pub(super) fn as_ref<'tree>(
&'tree self, &'tree self,
) -> ChildNodesRef<'tree, 'on_disk> { ) -> ChildNodesRef<'tree, 'on_disk> {
match self { match self {
ChildNodes::InMemory(nodes) => ChildNodesRef::InMemory(nodes), ChildNodes::InMemory(nodes) => ChildNodesRef::InMemory(nodes),
ChildNodes::OnDisk(nodes) => ChildNodesRef::OnDisk(nodes),
} }
} }
pub(super) fn is_empty(&self) -> bool { pub(super) fn is_empty(&self) -> bool {
match self { match self {
ChildNodes::InMemory(nodes) => nodes.is_empty(), ChildNodes::InMemory(nodes) => nodes.is_empty(),
ChildNodes::OnDisk(nodes) => nodes.is_empty(),
} }
} }
pub(super) fn make_mut( pub(super) fn make_mut(
&mut self, &mut self,
_on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result< ) -> Result<
&mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>, &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>,
DirstateV2ParseError, DirstateV2ParseError,
> { > {
match self { match self {
ChildNodes::InMemory(nodes) => Ok(nodes), ChildNodes::InMemory(nodes) => Ok(nodes),
ChildNodes::OnDisk(nodes) => {
let nodes = nodes
.iter()
.map(|node| {
Ok((
node.path(on_disk)?,
node.to_in_memory_node(on_disk)?,
))
})
.collect::<Result<_, _>>()?;
*self = ChildNodes::InMemory(nodes);
match self {
ChildNodes::InMemory(nodes) => Ok(nodes),
ChildNodes::OnDisk(_) => unreachable!(),
}
}
} }
} }
} }
impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> { impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> {
pub(super) fn get( pub(super) fn get(
&self, &self,
base_name: &HgPath, base_name: &HgPath,
_on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> { ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
match self { match self {
ChildNodesRef::InMemory(nodes) => Ok(nodes ChildNodesRef::InMemory(nodes) => Ok(nodes
.get_key_value(base_name) .get_key_value(base_name)
.map(|(k, v)| NodeRef::InMemory(k, v))), .map(|(k, v)| NodeRef::InMemory(k, v))),
ChildNodesRef::OnDisk(nodes) => {
let mut parse_result = Ok(());
let search_result = nodes.binary_search_by(|node| {
match node.base_name(on_disk) {
Ok(node_base_name) => node_base_name.cmp(base_name),
Err(e) => {
parse_result = Err(e);
// Dummy comparison result, `search_result` won’t
// be used since `parse_result` is an error
std::cmp::Ordering::Equal
}
}
});
parse_result.map(|()| {
search_result.ok().map(|i| NodeRef::OnDisk(&nodes[i]))
})
}
} }
} }
/// Iterate in undefined order /// Iterate in undefined order
pub(super) fn iter( pub(super) fn iter(
&self, &self,
) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> { ) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> {
match self { match self {
ChildNodesRef::InMemory(nodes) => { ChildNodesRef::InMemory(nodes) => itertools::Either::Left(
nodes.iter().map(|(k, v)| NodeRef::InMemory(k, v)) nodes.iter().map(|(k, v)| NodeRef::InMemory(k, v)),
),
ChildNodesRef::OnDisk(nodes) => {
itertools::Either::Right(nodes.iter().map(NodeRef::OnDisk))
} }
} }
} }
/// Iterate in parallel in undefined order /// Iterate in parallel in undefined order
pub(super) fn par_iter( pub(super) fn par_iter(
&self, &self,
) -> impl rayon::iter::ParallelIterator<Item = NodeRef<'tree, 'on_disk>> ) -> impl rayon::iter::ParallelIterator<Item = NodeRef<'tree, 'on_disk>>
{ {
use rayon::prelude::*; use rayon::prelude::*;
match self { match self {
ChildNodesRef::InMemory(nodes) => { ChildNodesRef::InMemory(nodes) => rayon::iter::Either::Left(
nodes.par_iter().map(|(k, v)| NodeRef::InMemory(k, v)) nodes.par_iter().map(|(k, v)| NodeRef::InMemory(k, v)),
} ),
ChildNodesRef::OnDisk(nodes) => rayon::iter::Either::Right(
nodes.par_iter().map(NodeRef::OnDisk),
),
} }
} }
pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> { pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> {
match self { match self {
ChildNodesRef::InMemory(nodes) => { ChildNodesRef::InMemory(nodes) => {
let mut vec: Vec<_> = nodes let mut vec: Vec<_> = nodes
.iter() .iter()
.map(|(k, v)| NodeRef::InMemory(k, v)) .map(|(k, v)| NodeRef::InMemory(k, v))
.collect(); .collect();
fn sort_key<'a>(node: &'a NodeRef) -> &'a HgPath { fn sort_key<'a>(node: &'a NodeRef) -> &'a HgPath {
match node { match node {
NodeRef::InMemory(path, _node) => path.base_name(), NodeRef::InMemory(path, _node) => path.base_name(),
NodeRef::OnDisk(_) => unreachable!(),
} }
} }
// `sort_unstable_by_key` doesn’t allow keys borrowing from the // `sort_unstable_by_key` doesn’t allow keys borrowing from the
// value: https://github.com/rust-lang/rust/issues/34162 // value: https://github.com/rust-lang/rust/issues/34162
vec.sort_unstable_by(|a, b| sort_key(a).cmp(sort_key(b))); vec.sort_unstable_by(|a, b| sort_key(a).cmp(sort_key(b)));
vec vec
} }
ChildNodesRef::OnDisk(nodes) => {
// Nodes on disk are already sorted
nodes.iter().map(NodeRef::OnDisk).collect()
}
} }
} }
} }
impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> { impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> {
pub(super) fn full_path( pub(super) fn full_path(
&self, &self,
_on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<&'tree HgPath, DirstateV2ParseError> { ) -> Result<&'tree HgPath, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => Ok(path.full_path()), NodeRef::InMemory(path, _node) => Ok(path.full_path()),
NodeRef::OnDisk(node) => node.full_path(on_disk),
} }
} }
/// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree /// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree
pub(super) fn full_path_cow( pub(super) fn full_path_cow(
&self, &self,
_on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<Cow<'on_disk, HgPath>, DirstateV2ParseError> { ) -> Result<Cow<'on_disk, HgPath>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => Ok(path.full_path().clone()), NodeRef::InMemory(path, _node) => Ok(path.full_path().clone()),
NodeRef::OnDisk(node) => {
Ok(Cow::Borrowed(node.full_path(on_disk)?))
}
} }
} }
pub(super) fn base_name( pub(super) fn base_name(
&self, &self,
_on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<&'tree HgPath, DirstateV2ParseError> { ) -> Result<&'tree HgPath, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => Ok(path.base_name()), NodeRef::InMemory(path, _node) => Ok(path.base_name()),
NodeRef::OnDisk(node) => node.base_name(on_disk),
} }
} }
pub(super) fn children( pub(super) fn children(
&self, &self,
_on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> { ) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()), NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()),
NodeRef::OnDisk(node) => {
Ok(ChildNodesRef::OnDisk(node.children(on_disk)?))
}
} }
} }
pub(super) fn has_copy_source(&self) -> bool { pub(super) fn has_copy_source(&self) -> bool {
match self { match self {
NodeRef::InMemory(_path, node) => node.copy_source.is_some(), NodeRef::InMemory(_path, node) => node.copy_source.is_some(),
NodeRef::OnDisk(node) => node.has_copy_source(),
} }
} }
pub(super) fn copy_source( pub(super) fn copy_source(
&self, &self,
_on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> { ) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => { NodeRef::InMemory(_path, node) => {
Ok(node.copy_source.as_ref().map(|s| &**s)) Ok(node.copy_source.as_ref().map(|s| &**s))
} }
NodeRef::OnDisk(node) => node.copy_source(on_disk),
} }
} }
pub(super) fn has_entry(&self) -> bool { pub(super) fn has_entry(&self) -> bool {
match self { match self {
NodeRef::InMemory(_path, node) => node.entry.is_some(), NodeRef::InMemory(_path, node) => node.entry.is_some(),
NodeRef::OnDisk(node) => node.has_entry(),
} }
} }
pub(super) fn entry( pub(super) fn entry(
&self, &self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => Ok(node.entry), NodeRef::InMemory(_path, node) => Ok(node.entry),
NodeRef::OnDisk(node) => node.entry(),
} }
} }
pub(super) fn state( pub(super) fn state(
&self, &self,
) -> Result<Option<EntryState>, DirstateV2ParseError> { ) -> Result<Option<EntryState>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => { NodeRef::InMemory(_path, node) => {
Ok(node.entry.as_ref().map(|entry| entry.state)) Ok(node.entry.as_ref().map(|entry| entry.state))
} }
NodeRef::OnDisk(node) => node.state(),
} }
} }
pub(super) fn tracked_descendants_count(&self) -> u32 { pub(super) fn tracked_descendants_count(&self) -> u32 {
match self { match self {
NodeRef::InMemory(_path, node) => node.tracked_descendants_count, NodeRef::InMemory(_path, node) => node.tracked_descendants_count,
NodeRef::OnDisk(node) => node.tracked_descendants_count.get(),
} }
} }
} }
/// Represents a file or a directory /// Represents a file or a directory
#[derive(Default)] #[derive(Default)]
pub(super) struct Node<'on_disk> { pub(super) struct Node<'on_disk> {
/// `None` for directories /// `None` for directories

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

use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef}; use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef};
use crate::dirstate_tree::path_with_basename::WithBasename; use crate::dirstate_tree::path_with_basename::WithBasename;
use crate::errors::HgError; use crate::errors::HgError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateParents; use crate::DirstateParents;
use crate::EntryState;
use bytes_cast::unaligned::{I32Be, U32Be, U64Be}; use bytes_cast::unaligned::{I32Be, U32Be, U64Be};
use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use std::borrow::Cow; use std::borrow::Cow;
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
/// Added at the start of `.hg/dirstate` when the "v2" format is used. /// Added at the start of `.hg/dirstate` when the "v2" format is used.
/// This a redundant sanity check more than an actual "magic number" since /// This a redundant sanity check more than an actual "magic number" since
/// `.hg/requires` already governs which format should be used. /// `.hg/requires` already governs which format should be used.
root: ChildNodes, root: ChildNodes,
nodes_with_entry_count: Size, nodes_with_entry_count: Size,
nodes_with_copy_source_count: Size, nodes_with_copy_source_count: Size,
} }
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
struct Node { pub(super) struct Node {
full_path: PathSlice, full_path: PathSlice,
/// In bytes from `self.full_path.start` /// In bytes from `self.full_path.start`
base_name_start: Size, base_name_start: Size,
copy_source: OptPathSlice, copy_source: OptPathSlice,
entry: OptEntry, entry: OptEntry,
children: ChildNodes, children: ChildNodes,
tracked_descendants_count: Size, pub(super) tracked_descendants_count: Size,
} }
/// Either nothing if `state == b'\0'`, or a dirstate entry like in the v1 /// Either nothing if `state == b'\0'`, or a dirstate entry like in the v1
/// format /// format
#[derive(BytesCast)] #[derive(BytesCast, Copy, Clone)]
#[repr(C)] #[repr(C)]
struct OptEntry { struct OptEntry {
state: u8, state: u8,
mode: I32Be, mode: I32Be,
mtime: I32Be, mtime: I32Be,
size: I32Be, size: I32Be,
} }
nodes_with_entry_count, nodes_with_entry_count,
nodes_with_copy_source_count, nodes_with_copy_source_count,
} = header; } = header;
if marker != V2_FORMAT_MARKER { if marker != V2_FORMAT_MARKER {
return Err(DirstateV2ParseError); return Err(DirstateV2ParseError);
} }
let dirstate_map = DirstateMap { let dirstate_map = DirstateMap {
on_disk, on_disk,
root: read_nodes(on_disk, *root)?, root: dirstate_map::ChildNodes::OnDisk(read_slice::<Node>(
on_disk, *root,
)?),
nodes_with_entry_count: nodes_with_entry_count.get(), nodes_with_entry_count: nodes_with_entry_count.get(),
nodes_with_copy_source_count: nodes_with_copy_source_count.get(), nodes_with_copy_source_count: nodes_with_copy_source_count.get(),
}; };
let parents = Some(parents.clone()); let parents = Some(parents.clone());
Ok((dirstate_map, parents)) Ok((dirstate_map, parents))
} }
impl Node { impl Node {
pub(super) fn path<'on_disk>( pub(super) fn full_path<'on_disk>(
&self, &self,
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<dirstate_map::NodeKey<'on_disk>, DirstateV2ParseError> { ) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
let full_path = read_hg_path(on_disk, self.full_path)?; read_hg_path(on_disk, self.full_path)
let base_name_start = usize::try_from(self.base_name_start.get()) }
pub(super) fn base_name_start<'on_disk>(
&self,
) -> Result<usize, DirstateV2ParseError> {
let start = self.base_name_start.get();
if start < self.full_path.len.get() {
let start = usize::try_from(start)
// u32 -> usize, could only panic on a 16-bit CPU // u32 -> usize, could only panic on a 16-bit CPU
.expect("dirstate-v2 base_name_start out of bounds"); .expect("dirstate-v2 base_name_start out of bounds");
if base_name_start < full_path.len() { Ok(start)
Ok(WithBasename::from_raw_parts(full_path, base_name_start))
} else { } else {
Err(DirstateV2ParseError) Err(DirstateV2ParseError)
} }
} }
pub(super) fn base_name<'on_disk>(
&self,
on_disk: &'on_disk [u8],
) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
let full_path = self.full_path(on_disk)?;
let base_name_start = self.base_name_start()?;
Ok(HgPath::new(&full_path.as_bytes()[base_name_start..]))
}
pub(super) fn path<'on_disk>(
&self,
on_disk: &'on_disk [u8],
) -> Result<dirstate_map::NodeKey<'on_disk>, DirstateV2ParseError> {
Ok(WithBasename::from_raw_parts(
Cow::Borrowed(self.full_path(on_disk)?),
self.base_name_start()?,
))
}
pub(super) fn has_copy_source<'on_disk>(&self) -> bool {
self.copy_source.start.get() != 0
}
pub(super) fn copy_source<'on_disk>( pub(super) fn copy_source<'on_disk>(
&self, &self,
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<Option<Cow<'on_disk, HgPath>>, DirstateV2ParseError> { ) -> Result<Option<&'on_disk HgPath>, DirstateV2ParseError> {
Ok(if self.copy_source.start.get() != 0 { Ok(if self.has_copy_source() {
Some(read_hg_path(on_disk, self.copy_source)?) Some(read_hg_path(on_disk, self.copy_source)?)
} else { } else {
None None
}) })
} }
pub(super) fn entry( pub(super) fn has_entry(&self) -> bool {
self.entry.state != b'\0'
}
pub(super) fn state(
&self, &self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<EntryState>, DirstateV2ParseError> {
Ok(if self.entry.state != b'\0' { Ok(if self.has_entry() {
Some(DirstateEntry { Some(
state: self self.entry
.entry
.state .state
.try_into() .try_into()
.map_err(|_| DirstateV2ParseError)?, .map_err(|_| DirstateV2ParseError)?,
mode: self.entry.mode.get(), )
mtime: self.entry.mtime.get(),
size: self.entry.size.get(),
})
} else { } else {
None None
}) })
} }
pub(super) fn entry(
&self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok(self.state()?.map(|state| DirstateEntry {
state,
mode: self.entry.mode.get(),
mtime: self.entry.mtime.get(),
size: self.entry.size.get(),
}))
}
pub(super) fn children<'on_disk>(
&self,
on_disk: &'on_disk [u8],
) -> Result<&'on_disk [Node], DirstateV2ParseError> {
read_slice::<Node>(on_disk, self.children)
}
pub(super) fn to_in_memory_node<'on_disk>( pub(super) fn to_in_memory_node<'on_disk>(
&self, &self,
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<dirstate_map::Node<'on_disk>, DirstateV2ParseError> { ) -> Result<dirstate_map::Node<'on_disk>, DirstateV2ParseError> {
Ok(dirstate_map::Node { Ok(dirstate_map::Node {
children: read_nodes(on_disk, self.children)?, children: dirstate_map::ChildNodes::OnDisk(
copy_source: self.copy_source(on_disk)?, self.children(on_disk)?,
),
copy_source: self.copy_source(on_disk)?.map(Cow::Borrowed),
entry: self.entry()?, entry: self.entry()?,
tracked_descendants_count: self.tracked_descendants_count.get(), tracked_descendants_count: self.tracked_descendants_count.get(),
}) })
} }
} }
fn read_nodes(
on_disk: &[u8],
slice: ChildNodes,
) -> Result<dirstate_map::ChildNodes, DirstateV2ParseError> {
read_slice::<Node>(on_disk, slice)?
.iter()
.map(|node| {
Ok((node.path(on_disk)?, node.to_in_memory_node(on_disk)?))
})
.collect::<Result<_, _>>()
.map(dirstate_map::ChildNodes::InMemory)
}
fn read_hg_path( fn read_hg_path(
on_disk: &[u8], on_disk: &[u8],
slice: Slice, slice: Slice,
) -> Result<Cow<HgPath>, DirstateV2ParseError> { ) -> Result<&HgPath, DirstateV2ParseError> {
let bytes = read_slice::<u8>(on_disk, slice)?; let bytes = read_slice::<u8>(on_disk, slice)?;
Ok(Cow::Borrowed(HgPath::new(bytes))) Ok(HgPath::new(bytes))
} }
fn read_slice<T>( fn read_slice<T>(
on_disk: &[u8], on_disk: &[u8],
slice: Slice, slice: Slice,
) -> Result<&[T], DirstateV2ParseError> ) -> Result<&[T], DirstateV2ParseError>
where where
T: BytesCast, T: BytesCast,
) -> Result<ChildNodes, DirstateError> { ) -> Result<ChildNodes, DirstateError> {
// `dirstate_map::ChildNodes` is a `HashMap` with undefined iteration // `dirstate_map::ChildNodes` is a `HashMap` with undefined iteration
// order. Sort to enable binary search in the written file. // order. Sort to enable binary search in the written file.
let nodes = nodes.sorted(); let nodes = nodes.sorted();
// First accumulate serialized nodes in a `Vec` // First accumulate serialized nodes in a `Vec`
let mut on_disk_nodes = Vec::with_capacity(nodes.len()); let mut on_disk_nodes = Vec::with_capacity(nodes.len());
for node in nodes { for node in nodes {
let children = node.children(dirstate_map.on_disk)?; let children = write_nodes(
let children = write_nodes(dirstate_map, children, out)?; dirstate_map,
node.children(dirstate_map.on_disk)?,
out,
)?;
let full_path = node.full_path(dirstate_map.on_disk)?; let full_path = node.full_path(dirstate_map.on_disk)?;
let full_path = write_slice::<u8>(full_path.as_bytes(), out); let full_path = write_slice::<u8>(full_path.as_bytes(), out);
let copy_source = let copy_source =
if let Some(source) = node.copy_source(dirstate_map.on_disk)? { if let Some(source) = node.copy_source(dirstate_map.on_disk)? {
write_slice::<u8>(source.as_bytes(), out) write_slice::<u8>(source.as_bytes(), out)
} else { } else {
Slice { Slice {
start: 0.into(), start: 0.into(),
OptEntry { OptEntry {
state: b'\0', state: b'\0',
mode: 0.into(), mode: 0.into(),
mtime: 0.into(), mtime: 0.into(),
size: 0.into(), size: 0.into(),
} }
}, },
}, },
NodeRef::OnDisk(node) => Node {
children,
copy_source,
full_path,
..*node
},
}) })
} }
// … so we can write them contiguously // … so we can write them contiguously
Ok(write_slice::<Node>(&on_disk_nodes, out)) Ok(write_slice::<Node>(&on_disk_nodes, out))
} }
fn write_slice<T>(slice: &[T], out: &mut Vec<u8>) -> Slice fn write_slice<T>(slice: &[T], out: &mut Vec<u8>) -> Slice
where where