This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10665

revlog: signal which revlog index are compatible with Rust
ClosedPublic

Authored by marmoute on May 4 2021, 10:16 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG9d1a8829f959: revlog: signal which revlog index are compatible with Rust
Summary

Otherwise, Rust may treat python object like cindex object, leading to
trouble. The new attribute is an integer because I expect we might need a flag
field in the future.

As a start we get the rust code to raise a clear TypeError. We will use the
information in a smarter way in the next changesets.

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.May 4 2021, 10:16 AM
baymax updated this revision to Diff 27904.May 11 2021, 1:47 PM

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

Alphare accepted this revision.May 17 2021, 5:49 PM
This revision is now accepted and ready to land.May 17 2021, 5:49 PM

Revision Contents
Changeset List

Diff 28058

mercurial/cext/parsers.c

{"fm1readmarkers", fm1readmarkers, METH_VARARGS, {"fm1readmarkers", fm1readmarkers, METH_VARARGS,
"parse v1 obsolete markers\n"}, "parse v1 obsolete markers\n"},
{NULL, NULL}}; {NULL, NULL}};
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 = 19; static const int version = 20;
static void module_init(PyObject *mod) static void module_init(PyObject *mod)
{ {
PyObject *capsule = NULL; 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

mercurial/cext/revlog.c

nodetree nt; /* base-16 trie */ nodetree nt; /* base-16 trie */
int ntinitialized; /* 0 or 1 */ int ntinitialized; /* 0 or 1 */
int ntrev; /* last rev scanned */ int ntrev; /* last rev scanned */
int ntlookups; /* # lookups */ int ntlookups; /* # lookups */
int ntmisses; /* # lookups that miss the cache */ int ntmisses; /* # lookups that miss the cache */
int inlined; int inlined;
long entry_size; /* size of index headers. Differs in v1 v.s. v2 format long entry_size; /* size of index headers. Differs in v1 v.s. v2 format
*/ */
long rust_ext_compat; /* compatibility with being used in rust
extensions */
char format_version; /* size of index headers. Differs in v1 v.s. v2 char format_version; /* size of index headers. Differs in v1 v.s. v2
format */ format */
}; };
static Py_ssize_t index_length(const indexObject *self) static Py_ssize_t index_length(const indexObject *self)
{ {
return self->length + self->new_length; return self->length + self->new_length;
} }
static const char nullid[32] = {0}; static const char nullid[32] = {0};
memset(&self->buf, 0, sizeof(self->buf)); memset(&self->buf, 0, sizeof(self->buf));
self->headrevs = NULL; self->headrevs = NULL;
self->filteredrevs = Py_None; self->filteredrevs = Py_None;
Py_INCREF(Py_None); Py_INCREF(Py_None);
self->ntinitialized = 0; self->ntinitialized = 0;
self->offsets = NULL; self->offsets = NULL;
self->nodelen = 20; self->nodelen = 20;
self->nullentry = NULL; self->nullentry = NULL;
self->rust_ext_compat = 1;
revlogv2 = NULL; revlogv2 = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", kwlist, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", kwlist,
&data_obj, &inlined_obj, &revlogv2)) &data_obj, &inlined_obj, &revlogv2))
return -1; return -1;
if (!PyObject_CheckBuffer(data_obj)) { if (!PyObject_CheckBuffer(data_obj)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"data does not support buffer interface"); "data does not support buffer interface");
static PyGetSetDef index_getset[] = { static PyGetSetDef index_getset[] = {
{"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL}, {"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyMemberDef index_members[] = { static PyMemberDef index_members[] = {
{"entry_size", T_LONG, offsetof(indexObject, entry_size), 0, {"entry_size", T_LONG, offsetof(indexObject, entry_size), 0,
"size of an index entry"}, "size of an index entry"},
{"rust_ext_compat", T_LONG, offsetof(indexObject, rust_ext_compat), 0,
"size of an index entry"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
PyTypeObject HgRevlogIndex_Type = { PyTypeObject HgRevlogIndex_Type = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"parsers.index", /* tp_name */ "parsers.index", /* tp_name */
sizeof(indexObject), /* tp_basicsize */ sizeof(indexObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */

mercurial/policy.py

# keep in sync with "version" in C modules # keep in sync with "version" in C modules
_cextversions = { _cextversions = {
('cext', 'base85'): 1, ('cext', 'base85'): 1,
('cext', 'bdiff'): 3, ('cext', 'bdiff'): 3,
('cext', 'mpatch'): 1, ('cext', 'mpatch'): 1,
('cext', 'osutil'): 4, ('cext', 'osutil'): 4,
('cext', 'parsers'): 19, ('cext', 'parsers'): 20,
} }
# map import request to other package or module # map import request to other package or module
_modredirects = { _modredirects = {
('cext', 'charencode'): ('cext', 'parsers'), ('cext', 'charencode'): ('cext', 'parsers'),
('cffi', 'base85'): ('pure', 'base85'), ('cffi', 'base85'): ('pure', 'base85'),
('cffi', 'charencode'): ('pure', 'charencode'), ('cffi', 'charencode'): ('pure', 'charencode'),
('cffi', 'parsers'): ('pure', 'parsers'), ('cffi', 'parsers'): ('pure', 'parsers'),

mercurial/pure/parsers.py

return int(q & 0xFFFF) return int(q & 0xFFFF)
def offset_type(offset, type): def offset_type(offset, type):
return int(int(offset) << 16 | type) return int(int(offset) << 16 | type)
class BaseIndexObject(object): class BaseIndexObject(object):
# Can I be passed to an algorithme implemented in Rust ?
rust_ext_compat = 0
# Format of an index entry according to Python's `struct` language # Format of an index entry according to Python's `struct` language
index_format = revlog_constants.INDEX_ENTRY_V1 index_format = revlog_constants.INDEX_ENTRY_V1
# Size of a C unsigned long long int, platform independent # Size of a C unsigned long long int, platform independent
big_int_size = struct.calcsize(b'>Q') big_int_size = struct.calcsize(b'>Q')
# Size of a C long int, platform independent # Size of a C long int, platform independent
int_size = struct.calcsize(b'>i') int_size = struct.calcsize(b'>i')
# An empty index entry, used as a default value to be overridden, or nullrev # An empty index entry, used as a default value to be overridden, or nullrev
null_item = ( null_item = (

mercurial/revlogutils/revlogv0.py

def offset_type(offset, type): def offset_type(offset, type):
if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0: if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
raise ValueError(b'unknown revlog index flags') raise ValueError(b'unknown revlog index flags')
return int(int(offset) << 16 | type) return int(int(offset) << 16 | type)
class revlogoldindex(list): class revlogoldindex(list):
rust_ext_compat = 0
entry_size = INDEX_ENTRY_V0.size entry_size = INDEX_ENTRY_V0.size
null_item = ( null_item = (
0, 0,
0, 0,
0, 0,
-1, -1,
-1, -1,
-1, -1,

rust/hg-cpython/src/cindex.rs

// cindex.rs // cindex.rs
// //
// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
// //
// 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 to use the Index defined by the parsers C extension //! Bindings to use the Index defined by the parsers C extension
//! //!
//! Ideally, we should use an Index entirely implemented in Rust, //! Ideally, we should use an Index entirely implemented in Rust,
//! but this will take some time to get there. //! but this will take some time to get there.
use cpython::{ use cpython::{
exc::ImportError, ObjectProtocol, PyClone, PyErr, PyObject, PyResult, exc::ImportError, exc::TypeError, ObjectProtocol, PyClone, PyErr,
PyTuple, Python, PythonObject, PyObject, PyResult, PyTuple, Python, PythonObject,
}; };
use hg::revlog::{Node, RevlogIndex}; use hg::revlog::{Node, RevlogIndex};
use hg::{Graph, GraphError, Revision, WORKING_DIRECTORY_REVISION}; use hg::{Graph, GraphError, Revision, WORKING_DIRECTORY_REVISION};
use libc::{c_int, ssize_t}; use libc::{c_int, ssize_t};
const REVLOG_CABI_VERSION: c_int = 2; const REVLOG_CABI_VERSION: c_int = 2;
#[repr(C)] #[repr(C)]
py, py,
format!( format!(
"ABI version mismatch: the C ABI revlog version {} \ "ABI version mismatch: the C ABI revlog version {} \
does not match the {} expected by Rust hg-cpython", does not match the {} expected by Rust hg-cpython",
capi.abi_version, REVLOG_CABI_VERSION capi.abi_version, REVLOG_CABI_VERSION
), ),
)); ));
} }
let compat: u64 = index.getattr(py, "rust_ext_compat")?.extract(py)?;
if compat == 0 {
return Err(PyErr::new::<TypeError, _>(
py,
"index object not compatible with Rust",
));
}
Ok(Index { index, capi }) Ok(Index { index, capi })
} }
/// return a reference to the CPython Index object in this Struct /// return a reference to the CPython Index object in this Struct
pub fn inner(&self) -> &PyObject { pub fn inner(&self) -> &PyObject {
&self.index &self.index
} }

rust/hg-cpython/src/revlog.rs

self.inner_update_nodemap_data(py, docket, nm_data) self.inner_update_nodemap_data(py, docket, nm_data)
} }
@property @property
def entry_size(&self) -> PyResult<PyInt> { def entry_size(&self) -> PyResult<PyInt> {
self.cindex(py).borrow().inner().getattr(py, "entry_size")?.extract::<PyInt>(py) self.cindex(py).borrow().inner().getattr(py, "entry_size")?.extract::<PyInt>(py)
} }
@property
def rust_ext_compat(&self) -> PyResult<PyInt> {
self.cindex(py).borrow().inner().getattr(py, "rust_ext_compat")?.extract::<PyInt>(py)
}
}); });
impl MixedIndex { impl MixedIndex {
fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> { fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> {
Self::create_instance( Self::create_instance(
py, py,
RefCell::new(cindex::Index::new(py, cindex)?), RefCell::new(cindex::Index::new(py, cindex)?),
RefCell::new(None), RefCell::new(None),