This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10556

rust: Read dirstate from disk in DirstateMap constructor
ClosedPublic

Authored by SimonSapin on May 3 2021, 6:25 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG9aba0cde0ed9: rust: Read dirstate from disk in DirstateMap constructor
rHG15c41fcccae3: rust: Read dirstate from disk in DirstateMap constructor
Summary

Before this changeset, Python code first creates an empty DirstateMap Rust
object, then immediately calls its read method with a byte string of the
contents of the .hg/dirstate file.

This makes that byte string available to the constructor of DirstateMap
in the hg-cpython crate. This is a first step towards enabling parts of
DirstateMap in the hg-core crate to borrow from this buffer without copying.

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 3 2021, 6:25 AM
Alphare accepted this revision.May 3 2021, 12:06 PM
This revision is now accepted and ready to land.May 3 2021, 12:06 PM
baymax updated this revision to Diff 27632.May 6 2021, 12:04 PM

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

Revision Contents
Changeset List

Diff 27666

mercurial/dirstate.py

return self._rustmap.clearambiguoustimes(*args, **kwargs) return self._rustmap.clearambiguoustimes(*args, **kwargs)
def nonnormalentries(self): def nonnormalentries(self):
return self._rustmap.nonnormalentries() return self._rustmap.nonnormalentries()
def get(self, *args, **kwargs): def get(self, *args, **kwargs):
return self._rustmap.get(*args, **kwargs) return self._rustmap.get(*args, **kwargs)
@propertycache
def _rustmap(self):
"""
Fills the Dirstatemap when called.
"""
use_dirstate_tree = self._ui.configbool(
b"experimental",
b"dirstate-tree.in-memory",
False,
)
self._rustmap = rustmod.DirstateMap(use_dirstate_tree)
self.read()
return self._rustmap
@property @property
def copymap(self): def copymap(self):
return self._rustmap.copymap() return self._rustmap.copymap()
def preload(self): def preload(self):
self._rustmap self._rustmap
def clear(self): def clear(self):
) )
else: else:
raise error.Abort( raise error.Abort(
_(b'working directory state appears damaged!') _(b'working directory state appears damaged!')
) )
return self._parents return self._parents
def read(self): @propertycache
def _rustmap(self):
"""
Fills the Dirstatemap when called.
"""
# ignore HG_PENDING because identity is used only for writing # ignore HG_PENDING because identity is used only for writing
self.identity = util.filestat.frompath( self.identity = util.filestat.frompath(
self._opener.join(self._filename) self._opener.join(self._filename)
) )
try: try:
fp = self._opendirstatefile() fp = self._opendirstatefile()
try: try:
st = fp.read() st = fp.read()
finally: finally:
fp.close() fp.close()
except IOError as err: except IOError as err:
if err.errno != errno.ENOENT: if err.errno != errno.ENOENT:
raise raise
return st = b''
if not st:
return use_dirstate_tree = self._ui.configbool(
b"experimental",
b"dirstate-tree.in-memory",
False,
)
self._rustmap, parents = rustmod.DirstateMap.new(
use_dirstate_tree, st
)
parse_dirstate = util.nogc(self._rustmap.read)
parents = parse_dirstate(st)
if parents and not self._dirtyparents: if parents and not self._dirtyparents:
self.setparents(*parents) self.setparents(*parents)
self.__contains__ = self._rustmap.__contains__ self.__contains__ = self._rustmap.__contains__
self.__getitem__ = self._rustmap.__getitem__ self.__getitem__ = self._rustmap.__getitem__
self.get = self._rustmap.get self.get = self._rustmap.get
return self._rustmap
def write(self, st, now): def write(self, st, now):
parents = self.parents() parents = self.parents()
st.write(self._rustmap.write(parents[0], parents[1], now)) st.write(self._rustmap.write(parents[0], parents[1], now))
st.close() st.close()
self._dirtyparents = False self._dirtyparents = False
@propertycache @propertycache

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

}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
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, DirstateMap as RustDirstateMap, DirsMultiset, DirstateEntry, DirstateError,
DirstateMapError, DirstateParents, EntryState, StateMapIter, DirstateMap as RustDirstateMap, DirstateMapError, 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.).
// This is ugly and hard to maintain. // This is ugly and hard to maintain.
// The same logic applies to `dirs` and `all_dirs`, however the `Dirs` // The same logic applies to `dirs` and `all_dirs`, however the `Dirs`
// `py_class!` is already implemented and does not mention // `py_class!` is already implemented and does not mention
// `RustDirstateMap`, rightfully so. // `RustDirstateMap`, rightfully so.
// All attributes also have to have a separate refcount data attribute for // All attributes also have to have a separate refcount data attribute for
// leaks, with all methods that go along for reference sharing. // leaks, with all methods that go along for reference sharing.
py_class!(pub class DirstateMap |py| { py_class!(pub class DirstateMap |py| {
@shared data inner: Box<dyn DirstateMapMethods + Send>; @shared data inner: Box<dyn DirstateMapMethods + Send>;
def __new__(_cls, use_dirstate_tree: bool) -> PyResult<Self> { /// Returns a `(dirstate_map, parents)` tuple
let inner = if use_dirstate_tree { @staticmethod
Box::new(hg::dirstate_tree::dirstate_map::DirstateMap::new()) as _ def new(use_dirstate_tree: bool, on_disk: PyBytes) -> PyResult<PyObject> {
let dirstate_error = |_: DirstateError| {
PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string())
};
let bytes = on_disk.data(py);
let (inner, parents) = if use_dirstate_tree {
let mut map = hg::dirstate_tree::dirstate_map::DirstateMap::new();
let parents = map.read(bytes).map_err(dirstate_error)?;
(Box::new(map) as _, parents)
} else { } else {
Box::new(RustDirstateMap::default()) as _ let mut map = RustDirstateMap::default();
let parents = map.read(bytes).map_err(dirstate_error)?;
(Box::new(map) as _, parents)
}; };
Self::create_instance(py, inner) let map = Self::create_instance(py, inner)?;
let parents = parents.map(|p| dirstate_parents_to_pytuple(py, &p));
Ok((map, parents).to_py_object(py).into_object())
} }
def clear(&self) -> PyResult<PyObject> { def clear(&self) -> PyResult<PyObject> {
self.inner(py).borrow_mut().clear(); self.inner(py).borrow_mut().clear();
Ok(py.None()) Ok(py.None())
} }
def get( def get(
Ok(self.inner(py).borrow_mut() Ok(self.inner(py).borrow_mut()
.has_dir(HgPath::new(d.data(py))) .has_dir(HgPath::new(d.data(py)))
.map_err(|e| { .map_err(|e| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})? })?
.to_py_object(py)) .to_py_object(py))
} }
def read(&self, st: PyObject) -> PyResult<Option<PyObject>> {
match self.inner(py).borrow_mut()
.read(st.extract::<PyBytes>(py)?.data(py))
{
Ok(Some(parents)) => Ok(Some(
dirstate_parents_to_pytuple(py, parents)
.into_object()
)),
Ok(None) => Ok(Some(py.None())),
Err(_) => Err(PyErr::new::<exc::OSError, _>(
py,
"Dirstate error".to_string(),
)),
}
}
def write( def write(
&self, &self,
p1: PyObject, p1: PyObject,
p2: PyObject, p2: PyObject,
now: PyObject now: PyObject
) -> PyResult<PyBytes> { ) -> PyResult<PyBytes> {
let now = Timestamp(now.extract(py)?); let now = Timestamp(now.extract(py)?);
let parents = DirstateParents { let parents = DirstateParents {