( )⚙ D10556 rust: Read dirstate from disk in DirstateMap constructor

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 27331

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 {