This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11837

rhg: Make Repo::dirstate_parents a LazyCell
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc8659e61073d: rhg: Make Repo::dirstate_parents a LazyCell
Summary

Unify with the same abstraction used for other lazily-initialized components

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:17 AM
This revision is now accepted and ready to land.Dec 3 2021, 6:17 AM
SimonSapin updated this revision to Diff 31318.Dec 6 2021, 5:03 AM
SimonSapin added a commit: rHGc8659e61073d: rhg: Make Repo::dirstate_parents a LazyCell.Dec 7 2021, 10:05 AM
Closed by commit rHGc8659e61073d: rhg: Make Repo::dirstate_parents a LazyCell (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/repo.rs (28 lines)

Diff 31318

rust/hg-core/src/repo.rs

use crate::revlog::filelog::Filelog; use crate::revlog::filelog::Filelog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::utils::SliceExt; use crate::utils::SliceExt;
use crate::vfs::{is_dir, is_file, Vfs}; use crate::vfs::{is_dir, is_file, Vfs};
use crate::{requirements, NodePrefix}; use crate::{requirements, NodePrefix};
use crate::{DirstateError, Revision}; use crate::{DirstateError, Revision};
use std::cell::{Cell, Ref, RefCell, RefMut}; use std::cell::{Ref, RefCell, RefMut};
use std::collections::HashSet; use std::collections::HashSet;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// 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,
// None means not known/initialized yet dirstate_parents: LazyCell<DirstateParents, HgError>,
dirstate_parents: Cell<Option<DirstateParents>>,
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: Cell::new(None), dirstate_parents: LazyCell::new(Self::read_dirstate_parents),
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)
Ok(self Ok(self
.hg_vfs() .hg_vfs()
.read("dirstate") .read("dirstate")
.io_not_found_as_none()? .io_not_found_as_none()?
.unwrap_or(Vec::new())) .unwrap_or(Vec::new()))
} }
pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> { pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> {
if let Some(parents) = self.dirstate_parents.get() { Ok(*self.dirstate_parents.get_or_init(self)?)
return Ok(parents);
} }
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() {
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() crate::dirstate_tree::on_disk::read_docket(&dirstate)?.parents()
} else { } else {
crate::dirstate::parsers::parse_dirstate_parents(&dirstate)? crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
.clone() .clone()
}; };
self.dirstate_parents.set(Some(parents)); self.dirstate_parents.set(parents);
Ok(parents) Ok(parents)
} }
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(Some(DirstateParents::NULL)); self.dirstate_parents.set(DirstateParents::NULL);
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(Some(docket.parents())); self.dirstate_parents.set(docket.parents());
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)
} else { } else {
OwningDirstateMap::new_empty(Vec::new()) OwningDirstateMap::new_empty(Vec::new())
}; };
let (on_disk, placeholder) = map.get_pair_mut(); let (on_disk, placeholder) = map.get_pair_mut();
*placeholder = DirstateMap::new_v2(on_disk, data_size, metadata)?; *placeholder = DirstateMap::new_v2(on_disk, data_size, metadata)?;
Ok(map) Ok(map)
} else { } else {
let mut map = OwningDirstateMap::new_empty(dirstate_file_contents); let mut map = OwningDirstateMap::new_empty(dirstate_file_contents);
let (on_disk, placeholder) = map.get_pair_mut(); let (on_disk, placeholder) = map.get_pair_mut();
let (inner, parents) = DirstateMap::new_v1(on_disk)?; let (inner, parents) = DirstateMap::new_v1(on_disk)?;
self.dirstate_parents self.dirstate_parents
.set(Some(parents.unwrap_or(DirstateParents::NULL))); .set(parents.unwrap_or(DirstateParents::NULL));
*placeholder = inner; *placeholder = inner;
Ok(map) Ok(map)
} }
} }
pub fn dirstate_map( pub fn dirstate_map(
&self, &self,
) -> Result<Ref<OwningDirstateMap>, DirstateError> { ) -> Result<Ref<OwningDirstateMap>, DirstateError> {
impl<T, E> LazyCell<T, E> { impl<T, E> LazyCell<T, E> {
fn new(init: impl Fn(&Repo) -> Result<T, E> + 'static) -> Self { fn new(init: impl Fn(&Repo) -> Result<T, E> + 'static) -> Self {
Self { Self {
value: RefCell::new(None), value: RefCell::new(None),
init: Box::new(init), init: Box::new(init),
} }
} }
fn set(&self, value: T) {
*self.value.borrow_mut() = Some(value)
}
fn get_or_init(&self, repo: &Repo) -> Result<Ref<T>, E> { fn get_or_init(&self, repo: &Repo) -> Result<Ref<T>, E> {
let mut borrowed = self.value.borrow(); let mut borrowed = self.value.borrow();
if borrowed.is_none() { if borrowed.is_none() {
drop(borrowed); drop(borrowed);
// Only use `borrow_mut` if it is really needed to avoid panic in // Only use `borrow_mut` if it is really needed to avoid panic in
// case there is another outstanding borrow but mutation is not // case there is another outstanding borrow but mutation is not
// needed. // needed.
*self.value.borrow_mut() = Some((self.init)(repo)?); *self.value.borrow_mut() = Some((self.init)(repo)?);
borrowed = self.value.borrow() borrowed = self.value.borrow()
} }
Ok(Ref::map(borrowed, |option| option.as_ref().unwrap())) Ok(Ref::map(borrowed, |option| option.as_ref().unwrap()))
} }
pub fn get_mut_or_init(&self, repo: &Repo) -> Result<RefMut<T>, E> { fn get_mut_or_init(&self, repo: &Repo) -> Result<RefMut<T>, E> {
let mut borrowed = self.value.borrow_mut(); let mut borrowed = self.value.borrow_mut();
if borrowed.is_none() { if borrowed.is_none() {
*borrowed = Some((self.init)(repo)?); *borrowed = Some((self.init)(repo)?);
} }
Ok(RefMut::map(borrowed, |option| option.as_mut().unwrap())) Ok(RefMut::map(borrowed, |option| option.as_mut().unwrap()))
} }
} }