( )⚙ D11486 dirstate: Use the Rust implementation of DirstateItem when Rust is enabled

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11486

dirstate: Use the Rust implementation of DirstateItem when Rust is enabled
ClosedPublic

Authored by SimonSapin on Sep 22 2021, 4:55 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGd5528ac9b4f2: dirstate: Use the Rust implementation of DirstateItem when Rust is enabled
Summary

… instead of the C implementation, with C/Rust conversions at the FFI boundary

Diff Detail

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

Revision Contents
Changeset List

Diff 30380

mercurial/cext/parsers.c

void dirs_module_init(PyObject *mod); void dirs_module_init(PyObject *mod);
void manifest_module_init(PyObject *mod); void manifest_module_init(PyObject *mod);
void revlog_module_init(PyObject *mod); void revlog_module_init(PyObject *mod);
static const int version = 20; static const int version = 20;
static void module_init(PyObject *mod) static void module_init(PyObject *mod)
{ {
PyObject *capsule = NULL;
PyModule_AddIntConstant(mod, "version", version); PyModule_AddIntConstant(mod, "version", version);
/* This module constant has two purposes. First, it lets us unit test /* This module constant has two purposes. First, it lets us unit test
* the ImportError raised without hard-coding any error text. This * the ImportError raised without hard-coding any error text. This
* means we can change the text in the future without breaking tests, * means we can change the text in the future without breaking tests,
* even across changesets without a recompile. Second, its presence * even across changesets without a recompile. Second, its presence
* can be used to determine whether the version-checking logic is * can be used to determine whether the version-checking logic is
* present, which also helps in testing across changesets without a * present, which also helps in testing across changesets without a
* recompile. Note that this means the pure-Python version of parsers * recompile. Note that this means the pure-Python version of parsers
* should not have this module constant. */ * should not have this module constant. */
PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext); PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext);
dirs_module_init(mod); dirs_module_init(mod);
manifest_module_init(mod); manifest_module_init(mod);
revlog_module_init(mod); revlog_module_init(mod);
capsule = PyCapsule_New(
dirstate_item_from_v1_data,
"mercurial.cext.parsers.make_dirstate_item_CAPI", NULL);
if (capsule != NULL)
PyModule_AddObject(mod, "make_dirstate_item_CAPI", capsule);
if (PyType_Ready(&dirstateItemType) < 0) { if (PyType_Ready(&dirstateItemType) < 0) {
return; return;
} }
Py_INCREF(&dirstateItemType); Py_INCREF(&dirstateItemType);
PyModule_AddObject(mod, "DirstateItem", (PyObject *)&dirstateItemType); PyModule_AddObject(mod, "DirstateItem", (PyObject *)&dirstateItemType);
} }
static int check_python_version(void) static int check_python_version(void)

mercurial/dirstate.py

rustmod = policy.importrust('dirstate') rustmod = policy.importrust('dirstate')
SUPPORTS_DIRSTATE_V2 = rustmod is not None SUPPORTS_DIRSTATE_V2 = rustmod is not None
propertycache = util.propertycache propertycache = util.propertycache
filecache = scmutil.filecache filecache = scmutil.filecache
_rangemask = dirstatemap.rangemask _rangemask = dirstatemap.rangemask
DirstateItem = parsers.DirstateItem DirstateItem = dirstatemap.DirstateItem
class repocache(filecache): class repocache(filecache):
"""filecache for files in .hg/""" """filecache for files in .hg/"""
def join(self, obj, fname): def join(self, obj, fname):
return obj._opener.join(fname) return obj._opener.join(fname)

mercurial/dirstatemap.py

docket as docketmod, docket as docketmod,
) )
parsers = policy.importmod('parsers') parsers = policy.importmod('parsers')
rustmod = policy.importrust('dirstate') rustmod = policy.importrust('dirstate')
propertycache = util.propertycache propertycache = util.propertycache
if rustmod is None:
DirstateItem = parsers.DirstateItem DirstateItem = parsers.DirstateItem
else:
DirstateItem = rustmod.DirstateItem
rangemask = 0x7FFFFFFF rangemask = 0x7FFFFFFF
class dirstatemap(object): class dirstatemap(object):
"""Map encapsulating the dirstate's contents. """Map encapsulating the dirstate's contents.
The dirstate contains the following state: The dirstate contains the following state:

rust/hg-cpython/src/dirstate.rs

mod status; mod status;
use self::item::DirstateItem; use self::item::DirstateItem;
use crate::{ use crate::{
dirstate::{ dirstate::{
dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
}, },
exceptions, exceptions,
}; };
use cpython::{ use cpython::{PyBytes, PyDict, PyList, PyModule, PyObject, PyResult, Python};
PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult, Python,
};
use hg::dirstate_tree::on_disk::V2_FORMAT_MARKER; use hg::dirstate_tree::on_disk::V2_FORMAT_MARKER;
use hg::DirstateEntry;
use libc::{c_char, c_int};
// C code uses a custom `dirstate_tuple` type, checks in multiple instances
// for this type, and raises a Python `Exception` if the check does not pass.
// Because this type differs only in name from the regular Python tuple, it
// would be a good idea in the near future to remove it entirely to allow
// for a pure Python tuple of the same effective structure to be used,
// rendering this type and the capsule below useless.
py_capsule_fn!(
from mercurial.cext.parsers import make_dirstate_item_CAPI
as make_dirstate_item_capi
signature (
state: c_char,
mode: c_int,
size: c_int,
mtime: c_int,
) -> *mut RawPyObject
);
pub fn make_dirstate_item(
py: Python,
entry: &DirstateEntry,
) -> PyResult<PyObject> {
// Explicitly go through u8 first, then cast to platform-specific `c_char`
// because Into<u8> has a specific implementation while `as c_char` would
// just do a naive enum cast.
let state_code: u8 = entry.state().into();
let make = make_dirstate_item_capi::retrieve(py)?;
let maybe_obj = unsafe {
let ptr = make(
state_code as c_char,
entry.mode(),
entry.size(),
entry.mtime(),
);
PyObject::from_owned_ptr_opt(py, ptr)
};
maybe_obj.ok_or_else(|| PyErr::fetch(py))
}
/// Create the module, with `__package__` given from parent /// Create the module, with `__package__` given from parent
pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> { pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
let dotted_name = &format!("{}.dirstate", package); let dotted_name = &format!("{}.dirstate", package);
let m = PyModule::new(py, dotted_name)?; let m = PyModule::new(py, dotted_name)?;
env_logger::init(); env_logger::init();

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_item, dirstate::item::DirstateItem,
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
pybytes_deref::PyBytesDeref, pybytes_deref::PyBytesDeref,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate::MTIME_UNSET, dirstate::MTIME_UNSET,
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
match self match self
.inner(py) .inner(py)
.borrow() .borrow()
.get(HgPath::new(key.data(py))) .get(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))? .map_err(|e| v2_error(py, e))?
{ {
Some(entry) => { Some(entry) => {
Ok(Some(make_dirstate_item(py, &entry)?)) Ok(Some(DirstateItem::new_as_pyobject(py, entry)?))
}, },
None => Ok(default) None => Ok(default)
} }
} }
def set_v1(&self, path: PyObject, item: PyObject) -> PyResult<PyObject> { def set_v1(&self, path: PyObject, item: PyObject) -> PyResult<PyObject> {
let f = path.extract::<PyBytes>(py)?; let f = path.extract::<PyBytes>(py)?;
let filename = HgPath::new(f.data(py)); let filename = HgPath::new(f.data(py));
let key = HgPath::new(key.data(py)); let key = HgPath::new(key.data(py));
match self match self
.inner(py) .inner(py)
.borrow() .borrow()
.get(key) .get(key)
.map_err(|e| v2_error(py, e))? .map_err(|e| v2_error(py, e))?
{ {
Some(entry) => { Some(entry) => {
Ok(make_dirstate_item(py, &entry)?) Ok(DirstateItem::new_as_pyobject(py, entry)?)
}, },
None => Err(PyErr::new::<exc::KeyError, _>( None => Err(PyErr::new::<exc::KeyError, _>(
py, py,
String::from_utf8_lossy(key.as_bytes()), String::from_utf8_lossy(key.as_bytes()),
)), )),
} }
} }
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>, res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
) -> PyResult<Option<(PyBytes, PyObject)>> { ) -> PyResult<Option<(PyBytes, PyObject)>> {
let (f, entry) = res.map_err(|e| v2_error(py, e))?; let (f, entry) = res.map_err(|e| v2_error(py, e))?;
Ok(Some(( Ok(Some((
PyBytes::new(py, f.as_bytes()), PyBytes::new(py, f.as_bytes()),
make_dirstate_item(py, &entry)?, DirstateItem::new_as_pyobject(py, entry)?,
))) )))
} }
} }
py_shared_iterator!( py_shared_iterator!(
DirstateMapKeysIterator, DirstateMapKeysIterator,
UnsafePyLeaked<StateMapIter<'static>>, UnsafePyLeaked<StateMapIter<'static>>,
DirstateMap::translate_key, DirstateMap::translate_key,