( )⚙ D10921 dirstate: Removed unused instances of `DirsMultiset`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10921

dirstate: Removed unused instances of `DirsMultiset`
ClosedPublic

Authored by SimonSapin on Jul 2 2021, 8:36 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGeb416759af7e: dirstate: Removed unused instances of `DirsMultiset`
Summary

… in Rust-backed dirstatemap.

The Python class dirstatemap had cached properties _dirs and _alldirs
that were not used for hastrackeddir and hasdir since they were redundant
with corresponding fields for the Rust DirstateMap struct.

dirfoldmap is modified to reuse instead the directory iterator introduced
in 3b9914b28133c0918186b6e8b9e4f1916e21338d.

Diff Detail

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

Revision Contents
Changeset List

Diff 28722

contrib/perf.py

def perfdirs(ui, repo, **opts): def perfdirs(ui, repo, **opts):
opts = _byteskwargs(opts) opts = _byteskwargs(opts)
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
dirstate = repo.dirstate dirstate = repo.dirstate
b'a' in dirstate b'a' in dirstate
def d(): def d():
dirstate.hasdir(b'a') dirstate.hasdir(b'a')
try:
del dirstate._map._dirs del dirstate._map._dirs
except AttributeError:
pass
timer(d) timer(d)
fm.end() fm.end()
@command( @command(
b'perf::dirstate|perfdirstate', b'perf::dirstate|perfdirstate',
[ [
@command(b'perf::dirstatedirs|perfdirstatedirs', formatteropts) @command(b'perf::dirstatedirs|perfdirstatedirs', formatteropts)
def perfdirstatedirs(ui, repo, **opts): def perfdirstatedirs(ui, repo, **opts):
"""benchmap a 'dirstate.hasdir' call from an empty `dirs` cache""" """benchmap a 'dirstate.hasdir' call from an empty `dirs` cache"""
opts = _byteskwargs(opts) opts = _byteskwargs(opts)
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
repo.dirstate.hasdir(b"a") repo.dirstate.hasdir(b"a")
def setup(): def setup():
try:
del repo.dirstate._map._dirs del repo.dirstate._map._dirs
except AttributeError:
pass
def d(): def d():
repo.dirstate.hasdir(b"a") repo.dirstate.hasdir(b"a")
timer(d, setup=setup) timer(d, setup=setup)
fm.end() fm.end()
""" """
opts = _byteskwargs(opts) opts = _byteskwargs(opts)
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
dirstate = repo.dirstate dirstate = repo.dirstate
dirstate._map.dirfoldmap.get(b'a') dirstate._map.dirfoldmap.get(b'a')
def setup(): def setup():
del dirstate._map.dirfoldmap del dirstate._map.dirfoldmap
try:
del dirstate._map._dirs del dirstate._map._dirs
except AttributeError:
pass
def d(): def d():
dirstate._map.dirfoldmap.get(b'a') dirstate._map.dirfoldmap.get(b'a')
timer(d, setup=setup) timer(d, setup=setup)
fm.end() fm.end()

mercurial/dirstate.py

@propertycache @propertycache
def filefoldmap(self): def filefoldmap(self):
"""Returns a dictionary mapping normalized case paths to their """Returns a dictionary mapping normalized case paths to their
non-normalized versions. non-normalized versions.
""" """
return self._rustmap.filefoldmapasdict() return self._rustmap.filefoldmapasdict()
def hastrackeddir(self, d): def hastrackeddir(self, d):
self._dirs # Trigger Python's propertycache
return self._rustmap.hastrackeddir(d) return self._rustmap.hastrackeddir(d)
def hasdir(self, d): def hasdir(self, d):
self._dirs # Trigger Python's propertycache
return self._rustmap.hasdir(d) return self._rustmap.hasdir(d)
@propertycache @propertycache
def _dirs(self):
return self._rustmap.getdirs()
@propertycache
def _alldirs(self):
return self._rustmap.getalldirs()
@propertycache
def identity(self): def identity(self):
self._rustmap self._rustmap
return self.identity return self.identity
@property @property
def nonnormalset(self): def nonnormalset(self):
nonnorm = self._rustmap.non_normal_entries() nonnorm = self._rustmap.non_normal_entries()
return nonnorm return nonnorm
@propertycache @propertycache
def otherparentset(self): def otherparentset(self):
otherparents = self._rustmap.other_parent_entries() otherparents = self._rustmap.other_parent_entries()
return otherparents return otherparents
def non_normal_or_other_parent_paths(self): def non_normal_or_other_parent_paths(self):
return self._rustmap.non_normal_or_other_parent_paths() return self._rustmap.non_normal_or_other_parent_paths()
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name in self._dirs: for name, _pseudo_entry in self.directories():
f[normcase(name)] = name f[normcase(name)] = name
return f return f

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

} }
// Borrow of `self` ends here since we collect cloned paths // Borrow of `self` ends here since we collect cloned paths
self.clear_known_ambiguous_mtimes(&paths)?; self.clear_known_ambiguous_mtimes(&paths)?;
on_disk::write(self, parents) on_disk::write(self, parents)
} }
fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
// Do nothing, this `DirstateMap` does not a separate `all_dirs` that
// needs to be recomputed
Ok(())
}
fn set_dirs(&mut self) -> Result<(), DirstateError> {
// Do nothing, this `DirstateMap` does not a separate `dirs` that needs
// to be recomputed
Ok(())
}
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {

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

) -> Result<Vec<u8>, DirstateError>; ) -> Result<Vec<u8>, DirstateError>;
fn pack_v2( fn pack_v2(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError>; ) -> Result<Vec<u8>, DirstateError>;
fn set_all_dirs(&mut self) -> Result<(), DirstateError>;
fn set_dirs(&mut self) -> Result<(), DirstateError>;
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>; ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
_parents: DirstateParents, _parents: DirstateParents,
_now: Timestamp, _now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
panic!( panic!(
"should have used dirstate_tree::DirstateMap to use the v2 format" "should have used dirstate_tree::DirstateMap to use the v2 format"
) )
} }
fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
self.set_all_dirs()
}
fn set_dirs(&mut self) -> Result<(), DirstateError> {
self.set_dirs()
}
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {

rust/hg-cpython/src/dirstate/dirstate_map.rs

use cpython::{ use cpython::{
exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject, PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject,
UnsafePyLeaked, UnsafePyLeaked,
}; };
use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::make_dirstate_tuple,
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
dirstate::owning::OwningDirstateMap, dirstate::owning::OwningDirstateMap,
dirstate::{dirs_multiset::Dirs, make_dirstate_tuple},
parsers::dirstate_parents_to_pytuple, parsers::dirstate_parents_to_pytuple,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
dirstate_tree::on_disk::DirstateV2ParseError, dirstate_tree::on_disk::DirstateV2ParseError,
errors::HgError, errors::HgError,
revlog::Node, revlog::Node,
utils::files::normalize_case, utils::files::normalize_case,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirstateEntry, DirstateError, DirstateEntry, DirstateError, DirstateMap as RustDirstateMap,
DirstateMap as RustDirstateMap, DirstateParents, EntryState, StateMapIter, DirstateParents, EntryState, StateMapIter,
}; };
// TODO // TODO
// This object needs to share references to multiple members of its Rust // This object needs to share references to multiple members of its Rust
// inner struct, namely `copy_map`, `dirs` and `all_dirs`. // inner struct, namely `copy_map`, `dirs` and `all_dirs`.
// Right now `CopyMap` is done, but it needs to have an explicit reference // Right now `CopyMap` is done, but it needs to have an explicit reference
// to `RustDirstateMap` which itself needs to have an encapsulation for // to `RustDirstateMap` which itself needs to have an encapsulation for
// every method in `CopyMap` (copymapcopy, etc.). // every method in `CopyMap` (copymapcopy, etc.).
def __iter__(&self) -> PyResult<DirstateMapKeysIterator> { def __iter__(&self) -> PyResult<DirstateMapKeysIterator> {
let leaked_ref = self.inner(py).leak_immutable(); let leaked_ref = self.inner(py).leak_immutable();
DirstateMapKeysIterator::from_inner( DirstateMapKeysIterator::from_inner(
py, py,
unsafe { leaked_ref.map(py, |o| o.iter()) }, unsafe { leaked_ref.map(py, |o| o.iter()) },
) )
} }
def getdirs(&self) -> PyResult<Dirs> {
// TODO don't copy, share the reference
self.inner(py).borrow_mut().set_dirs()
.map_err(|e| {
PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?;
Dirs::from_inner(
py,
DirsMultiset::from_dirstate(
self.inner(py).borrow().iter(),
Some(EntryState::Removed),
)
.map_err(|e| {
PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?,
)
}
def getalldirs(&self) -> PyResult<Dirs> {
// TODO don't copy, share the reference
self.inner(py).borrow_mut().set_all_dirs()
.map_err(|e| {
PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?;
Dirs::from_inner(
py,
DirsMultiset::from_dirstate(
self.inner(py).borrow().iter(),
None,
).map_err(|e| {
PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?,
)
}
// TODO all copymap* methods, see docstring above // TODO all copymap* methods, see docstring above
def copymapcopy(&self) -> PyResult<PyDict> { def copymapcopy(&self) -> PyResult<PyDict> {
let dict = PyDict::new(py); let dict = PyDict::new(py);
for item in self.inner(py).borrow().copy_map_iter() { for item in self.inner(py).borrow().copy_map_iter() {
let (key, value) = item.map_err(|e| v2_error(py, e))?; let (key, value) = item.map_err(|e| v2_error(py, e))?;
dict.set_item( dict.set_item(
py, py,
PyBytes::new(py, key.as_bytes()), PyBytes::new(py, key.as_bytes()),

rust/hg-cpython/src/dirstate/dispatch.rs

fn pack_v2( fn pack_v2(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
self.get_mut().pack_v2(parents, now) self.get_mut().pack_v2(parents, now)
} }
fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
self.get_mut().set_all_dirs()
}
fn set_dirs(&mut self) -> Result<(), DirstateError> {
self.get_mut().set_dirs()
}
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {