This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11838

rhg: Add lazy/cached dirstate data file ID parsing on Repo
ClosedPublic

Authored by SimonSapin on Dec 2 2021, 11:48 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc7c23bb036c9: rhg: Add lazy/cached dirstate data file ID parsing on Repo
Summary

The dirstate_parents, dirstate_data_file_uuid, and dirstate_map members
of Repo can be access in any order and the .hg/dirstate file should only
be opened once.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Dec 2 2021, 11:48 AM
Alphare accepted this revision.Dec 3 2021, 6:19 AM
This revision is now accepted and ready to land.Dec 3 2021, 6:19 AM
SimonSapin updated this revision to Diff 31319.Dec 6 2021, 5:03 AM

Revision Contents
Changeset List

Diff 31319

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

/// Counted in bytes /// Counted in bytes
data_size: Size, data_size: Size,
uuid_size: u8, uuid_size: u8,
} }
pub struct Docket<'on_disk> { pub struct Docket<'on_disk> {
header: &'on_disk DocketHeader, header: &'on_disk DocketHeader,
uuid: &'on_disk [u8], pub uuid: &'on_disk [u8],
} }
/// Fields are documented in the *Tree metadata in the docket file* /// Fields are documented in the *Tree metadata in the docket file*
/// section of `mercurial/helptext/internals/dirstate-v2.txt` /// section of `mercurial/helptext/internals/dirstate-v2.txt`
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
struct TreeMetadata { struct TreeMetadata {
root_nodes: ChildNodes, root_nodes: ChildNodes,

rust/hg-core/src/repo.rs

/// A repository on disk /// A repository on disk
pub struct Repo { pub struct Repo {
working_directory: PathBuf, working_directory: PathBuf,
dot_hg: PathBuf, dot_hg: PathBuf,
store: PathBuf, store: PathBuf,
requirements: HashSet<String>, requirements: HashSet<String>,
config: Config, config: Config,
dirstate_parents: LazyCell<DirstateParents, HgError>, dirstate_parents: LazyCell<DirstateParents, HgError>,
dirstate_data_file_uuid: LazyCell<Option<Vec<u8>>, HgError>,
dirstate_map: LazyCell<OwningDirstateMap, DirstateError>, dirstate_map: LazyCell<OwningDirstateMap, DirstateError>,
changelog: LazyCell<Changelog, HgError>, changelog: LazyCell<Changelog, HgError>,
manifestlog: LazyCell<Manifestlog, HgError>, manifestlog: LazyCell<Manifestlog, HgError>,
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum RepoError { pub enum RepoError {
NotFound { NotFound {
let repo = Self { let repo = Self {
requirements: reqs, requirements: reqs,
working_directory, working_directory,
store: store_path, store: store_path,
dot_hg, dot_hg,
config: repo_config, config: repo_config,
dirstate_parents: LazyCell::new(Self::read_dirstate_parents), dirstate_parents: LazyCell::new(Self::read_dirstate_parents),
dirstate_data_file_uuid: LazyCell::new(
Self::read_dirstate_data_file_uuid,
),
dirstate_map: LazyCell::new(Self::new_dirstate_map), dirstate_map: LazyCell::new(Self::new_dirstate_map),
changelog: LazyCell::new(Changelog::open), changelog: LazyCell::new(Changelog::open),
manifestlog: LazyCell::new(Manifestlog::open), manifestlog: LazyCell::new(Manifestlog::open),
}; };
requirements::check(&repo)?; requirements::check(&repo)?;
Ok(repo) Ok(repo)
pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> { pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> {
Ok(*self.dirstate_parents.get_or_init(self)?) Ok(*self.dirstate_parents.get_or_init(self)?)
} }
fn read_dirstate_parents(&self) -> Result<DirstateParents, HgError> { fn read_dirstate_parents(&self) -> Result<DirstateParents, HgError> {
let dirstate = self.dirstate_file_contents()?; let dirstate = self.dirstate_file_contents()?;
let parents = if dirstate.is_empty() { let parents = if dirstate.is_empty() {
if self.has_dirstate_v2() {
self.dirstate_data_file_uuid.set(None);
}
DirstateParents::NULL DirstateParents::NULL
} else if self.has_dirstate_v2() { } else if self.has_dirstate_v2() {
crate::dirstate_tree::on_disk::read_docket(&dirstate)?.parents() let docket =
crate::dirstate_tree::on_disk::read_docket(&dirstate)?;
self.dirstate_data_file_uuid
.set(Some(docket.uuid.to_owned()));
docket.parents()
} else { } else {
crate::dirstate::parsers::parse_dirstate_parents(&dirstate)? crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
.clone() .clone()
}; };
self.dirstate_parents.set(parents); self.dirstate_parents.set(parents);
Ok(parents) Ok(parents)
} }
fn read_dirstate_data_file_uuid(
&self,
) -> Result<Option<Vec<u8>>, HgError> {
assert!(
self.has_dirstate_v2(),
"accessing dirstate data file ID without dirstate-v2"
);
let dirstate = self.dirstate_file_contents()?;
if dirstate.is_empty() {
self.dirstate_parents.set(DirstateParents::NULL);
Ok(None)
} else {
let docket =
crate::dirstate_tree::on_disk::read_docket(&dirstate)?;
self.dirstate_parents.set(docket.parents());
Ok(Some(docket.uuid.to_owned()))
}
}
fn new_dirstate_map(&self) -> Result<OwningDirstateMap, DirstateError> { fn new_dirstate_map(&self) -> Result<OwningDirstateMap, DirstateError> {
let dirstate_file_contents = self.dirstate_file_contents()?; let dirstate_file_contents = self.dirstate_file_contents()?;
if dirstate_file_contents.is_empty() { if dirstate_file_contents.is_empty() {
self.dirstate_parents.set(DirstateParents::NULL); self.dirstate_parents.set(DirstateParents::NULL);
if self.has_dirstate_v2() {
self.dirstate_data_file_uuid.set(None);
}
Ok(OwningDirstateMap::new_empty(Vec::new())) Ok(OwningDirstateMap::new_empty(Vec::new()))
} else if self.has_dirstate_v2() { } else if self.has_dirstate_v2() {
let docket = crate::dirstate_tree::on_disk::read_docket( let docket = crate::dirstate_tree::on_disk::read_docket(
&dirstate_file_contents, &dirstate_file_contents,
)?; )?;
self.dirstate_parents.set(docket.parents()); self.dirstate_parents.set(docket.parents());
self.dirstate_data_file_uuid
.set(Some(docket.uuid.to_owned()));
let data_size = docket.data_size(); let data_size = docket.data_size();
let metadata = docket.tree_metadata(); let metadata = docket.tree_metadata();
let mut map = if let Some(data_mmap) = self let mut map = if let Some(data_mmap) = self
.hg_vfs() .hg_vfs()
.mmap_open(docket.data_filename()) .mmap_open(docket.data_filename())
.io_not_found_as_none()? .io_not_found_as_none()?
{ {
OwningDirstateMap::new_empty(data_mmap) OwningDirstateMap::new_empty(data_mmap)