This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8111

rust-dirstatemap: add `NonNormalEntries` class
ClosedPublic

Authored by marmoute on Feb 12 2020, 6:33 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG71e13cfd6154: rust-dirstatemap: add `NonNormalEntries` class
Summary

This fix introduces the same encapsulation as the copymap. There is no easy
way of doing this any better for now.

hg up -r null && time HGRCPATH= HGMODULEPOLICY=rust+c hg up tip on Mozilla
Central, (not super recent, but it doesn't matter):

Before: 7:44,08 total
After: 1:03,23 total

Pretty brutal regression!

This is a graft on stable of cf1f8660e568

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

marmoute created this revision.Feb 12 2020, 6:33 PM

INTENDED FOR STABLE

Alphare added a commit: rHG71e13cfd6154: rust-dirstatemap: add `NonNormalEntries` class.Feb 13 2020, 10:56 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG71e13cfd6154: rust-dirstatemap: add `NonNormalEntries` class (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 20182

mercurial/dirstate.py

@propertycache @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, otherparents = self._rustmap.nonnormalentries() nonnorm = self._rustmap.non_normal_entries()
return nonnorm return nonnorm
@propertycache @propertycache
def otherparentset(self): def otherparentset(self):
nonnorm, otherparents = self._rustmap.nonnormalentries() otherparents = self._rustmap.other_parent_entries()
return otherparents return otherparents
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name in self._dirs: for name in self._dirs:
f[normcase(name)] = name f[normcase(name)] = name
return f return f

rust/hg-cpython/src/dirstate.rs

// dirstate.rs // dirstate.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate` module provided by the //! Bindings for the `hg::dirstate` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.dirstate` //! From Python, this will be seen as `mercurial.rustext.dirstate`
mod copymap; mod copymap;
mod dirs_multiset; mod dirs_multiset;
mod dirstate_map; mod dirstate_map;
mod non_normal_entries;
mod status; mod status;
use crate::dirstate::{ use crate::dirstate::{
dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
}; };
use cpython::{ use cpython::{
exc, PyBytes, PyDict, PyErr, PyModule, PyObject, PyResult, PySequence, exc, PyBytes, PyDict, PyErr, PyModule, PyObject, PyResult, PySequence,
Python, Python,
}; };

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

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate::dirstate_map` file provided by the //! Bindings for the `hg::dirstate::dirstate_map` file provided by the
//! `hg-core` package. //! `hg-core` package.
use std::cell::{Ref, RefCell}; use std::cell::{Ref, RefCell};
use std::convert::TryInto; use std::convert::TryInto;
use std::time::Duration; use std::time::Duration;
use cpython::{ use cpython::{
exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyObject, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
PyResult, PyTuple, Python, PythonObject, ToPyObject, PyObject, PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject,
}; };
use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::non_normal_entries::NonNormalEntries,
dirstate::{dirs_multiset::Dirs, make_dirstate_tuple}, dirstate::{dirs_multiset::Dirs, make_dirstate_tuple},
ref_sharing::{PyLeaked, PySharedRefCell}, ref_sharing::{PyLeaked, PySharedRefCell},
}; };
use hg::{ use hg::{
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap, DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap,
DirstateMapError, DirstateParents, DirstateParseError, EntryState, DirstateMapError, DirstateParents, DirstateParseError, EntryState,
StateMapIter, PARENT_SIZE, StateMapIter, PARENT_SIZE,
)) ))
}) })
.collect(); .collect();
self.inner_shared(py).borrow_mut()? self.inner_shared(py).borrow_mut()?
.clear_ambiguous_times(files?, now.extract(py)?); .clear_ambiguous_times(files?, now.extract(py)?);
Ok(py.None()) Ok(py.None())
} }
// TODO share the reference def other_parent_entries(&self) -> PyResult<PyObject> {
def nonnormalentries(&self) -> PyResult<PyObject> { let mut inner_shared = self.inner_shared(py).borrow_mut()?;
let (non_normal, other_parent) = let (_, other_parent) =
self.inner_shared(py).borrow().non_normal_other_parent_entries(); inner_shared.get_non_normal_other_parent_entries();
let locals = PyDict::new(py); let locals = PyDict::new(py);
locals.set_item( locals.set_item(
py, py,
"non_normal",
non_normal
.iter()
.map(|v| PyBytes::new(py, v.as_ref()))
.collect::<Vec<PyBytes>>()
.to_py_object(py),
)?;
locals.set_item(
py,
"other_parent", "other_parent",
other_parent other_parent.as_ref()
.unwrap()
.iter() .iter()
.map(|v| PyBytes::new(py, v.as_ref())) .map(|v| PyBytes::new(py, v.as_ref()))
.collect::<Vec<PyBytes>>() .collect::<Vec<PyBytes>>()
.to_py_object(py), .to_py_object(py),
)?; )?;
py.eval("set(non_normal), set(other_parent)", None, Some(&locals)) py.eval("set(other_parent)", None, Some(&locals))
}
def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
NonNormalEntries::from_inner(py, self.clone_ref(py))
}
def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {
let key = key.extract::<PyBytes>(py)?;
Ok(self
.inner_shared(py)
.borrow_mut()?
.get_non_normal_other_parent_entries().0
.as_ref()
.unwrap()
.contains(HgPath::new(key.data(py))))
}
def non_normal_entries_display(&self) -> PyResult<PyString> {
Ok(
PyString::new(
py,
&format!(
"NonNormalEntries: {:?}",
self
.inner_shared(py)
.borrow_mut()?
.get_non_normal_other_parent_entries().0
.as_ref()
.unwrap().iter().map(|o| o))
)
)
}
def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?;
self
.inner_shared(py)
.borrow_mut()?
.non_normal_entries_remove(HgPath::new(key.data(py)));
Ok(py.None())
}
def non_normal_entries_union(&self, other: PyObject) -> PyResult<PyList> {
let other: PyResult<_> = other.iter(py)?
.map(|f| {
Ok(HgPathBuf::from_bytes(
f?.extract::<PyBytes>(py)?.data(py),
))
})
.collect();
let res = self
.inner_shared(py)
.borrow_mut()?
.non_normal_entries_union(other?);
let ret = PyList::new(py, &[]);
for (i, filename) in res.iter().enumerate() {
let as_pystring = PyBytes::new(py, filename.as_bytes());
ret.insert_item(py, i, as_pystring.into_object());
}
Ok(ret)
} }
def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> { def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
let d = d.extract::<PyBytes>(py)?; let d = d.extract::<PyBytes>(py)?;
Ok(self.inner_shared(py).borrow_mut()? Ok(self.inner_shared(py).borrow_mut()?
.has_tracked_dir(HgPath::new(d.data(py))) .has_tracked_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())

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

  • This file was added.
// non_normal_other_parent_entries.rs
//
// Copyright 2020 Raphaël Gomès <rgomes@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
use cpython::{
exc::NotImplementedError, CompareOp, ObjectProtocol, PyErr, PyList,
PyObject, PyResult, PyString, Python, PythonObject, ToPyObject,
};
use crate::dirstate::DirstateMap;
py_class!(pub class NonNormalEntries |py| {
data dmap: DirstateMap;
def __contains__(&self, key: PyObject) -> PyResult<bool> {
self.dmap(py).non_normal_entries_contains(py, key)
}
def remove(&self, key: PyObject) -> PyResult<PyObject> {
self.dmap(py).non_normal_entries_remove(py, key)
}
def union(&self, other: PyObject) -> PyResult<PyList> {
self.dmap(py).non_normal_entries_union(py, other)
}
def __richcmp__(&self, other: PyObject, op: CompareOp) -> PyResult<bool> {
match op {
CompareOp::Eq => self.is_equal_to(py, other),
CompareOp::Ne => Ok(!self.is_equal_to(py, other)?),
_ => Err(PyErr::new::<NotImplementedError, _>(py, ""))
}
}
def __repr__(&self) -> PyResult<PyString> {
self.dmap(py).non_normal_entries_display(py)
}
});
impl NonNormalEntries {
pub fn from_inner(py: Python, dm: DirstateMap) -> PyResult<Self> {
Self::create_instance(py, dm)
}
fn is_equal_to(&self, py: Python, other: PyObject) -> PyResult<bool> {
for item in other.iter(py)? {
if !self.dmap(py).non_normal_entries_contains(py, item?)? {
return Ok(false);
}
}
Ok(true)
}
}