( )⚙ D12179 revlog: register changelogv2 C implementation in parsers

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12179

revlog: register changelogv2 C implementation in parsers
ClosedPublic

Authored by pacien on Feb 14 2022, 1:06 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG1bb62821f080: revlog: register changelogv2 C implementation in parsers
rHG8b7bc75ea867: revlog: register changelogv2 C implementation in parsers
Summary

This allows Python code to make use of the C implementation of the changelogv2
base operations when the C extensions are enabled.

The format_version values are now shared between the C and Python sides,
avoiding an additional translation for the selection of the format version to
use.

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.

Revision Contents
Changeset List

Diff 32208

mercurial/cext/revlog.c

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 long rust_ext_compat; /* compatibility with being used in rust
extensions */ extensions */
char format_version; /* size of index headers. Differs in v1 v.s. v2 long format_version; /* format version selector (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};
#endif #endif
/* A RevlogNG v1 index entry is 64 bytes long. */ /* A RevlogNG v1 index entry is 64 bytes long. */
static const long v1_entry_size = 64; static const long v1_entry_size = 64;
/* A Revlogv2 index entry is 96 bytes long. */ /* A Revlogv2 index entry is 96 bytes long. */
static const long v2_entry_size = 96; static const long v2_entry_size = 96;
static const long format_v1 = 1; /* Internal only, could be any number */ /* A Changelogv2 index entry is 96 bytes long. */
static const long format_v2 = 2; /* Internal only, could be any number */ static const long cl2_entry_size = 96;
static const long format_cl2 = 3; /* Internal only, could be any number */
/* Internal format version.
* Must match their counterparts in revlogutils/constants.py */
static const long format_v1 = 1; /* constants.py: REVLOGV1 */
static const long format_v2 = 0xDEAD; /* constants.py: REVLOGV2 */
static const long format_cl2 = 0xD34D; /* constants.py: CHANGELOGV2 */
static const long entry_v1_offset_high = 0; static const long entry_v1_offset_high = 0;
static const long entry_v1_offset_offset_flags = 4; static const long entry_v1_offset_offset_flags = 4;
static const long entry_v1_offset_comp_len = 8; static const long entry_v1_offset_comp_len = 8;
static const long entry_v1_offset_uncomp_len = 12; static const long entry_v1_offset_uncomp_len = 12;
static const long entry_v1_offset_base_rev = 16; static const long entry_v1_offset_base_rev = 16;
static const long entry_v1_offset_link_rev = 20; static const long entry_v1_offset_link_rev = 20;
static const long entry_v1_offset_parent_1 = 24; static const long entry_v1_offset_parent_1 = 24;
return -1; return -1;
} }
return len; return len;
} }
static int index_init(indexObject *self, PyObject *args, PyObject *kwargs) static int index_init(indexObject *self, PyObject *args, PyObject *kwargs)
{ {
PyObject *data_obj, *inlined_obj, *revlogv2; PyObject *data_obj, *inlined_obj;
Py_ssize_t size; Py_ssize_t size;
static char *kwlist[] = {"data", "inlined", "revlogv2", NULL}; static char *kwlist[] = {"data", "inlined", "format", NULL};
/* Initialize before argument-checking to avoid index_dealloc() crash. /* Initialize before argument-checking to avoid index_dealloc() crash.
*/ */
self->added = NULL; self->added = NULL;
self->new_length = 0; self->new_length = 0;
self->added_length = 0; self->added_length = 0;
self->data = NULL; self->data = NULL;
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; self->rust_ext_compat = 1;
self->format_version = format_v1;
revlogv2 = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|l", kwlist,
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", kwlist, &data_obj, &inlined_obj,
&data_obj, &inlined_obj, &revlogv2)) &(self->format_version)))
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");
return -1; return -1;
} }
if (self->nodelen < 20 || self->nodelen > (Py_ssize_t)sizeof(nullid)) { if (self->nodelen < 20 || self->nodelen > (Py_ssize_t)sizeof(nullid)) {
PyErr_SetString(PyExc_RuntimeError, "unsupported node size"); PyErr_SetString(PyExc_RuntimeError, "unsupported node size");
return -1; return -1;
} }
if (revlogv2 && PyObject_IsTrue(revlogv2)) { if (self->format_version == format_v1) {
self->format_version = format_v2;
self->entry_size = v2_entry_size;
} else {
self->format_version = format_v1;
self->entry_size = v1_entry_size; self->entry_size = v1_entry_size;
} else if (self->format_version == format_v2) {
self->entry_size = v2_entry_size;
} else if (self->format_version == format_cl2) {
self->entry_size = cl2_entry_size;
} }
self->nullentry = self->nullentry =
Py_BuildValue(PY23("iiiiiiis#iiBBi", "iiiiiiiy#iiBBi"), 0, 0, 0, -1, Py_BuildValue(PY23("iiiiiiis#iiBBi", "iiiiiiiy#iiBBi"), 0, 0, 0, -1,
-1, -1, -1, nullid, self->nodelen, 0, 0, -1, -1, -1, nullid, self->nodelen, 0, 0,
comp_mode_inline, comp_mode_inline, rank_unknown); comp_mode_inline, comp_mode_inline, rank_unknown);
if (!self->nullentry) if (!self->nullentry)

mercurial/pure/parsers.py

self._extra = [] self._extra = []
else: else:
self._extra = self._extra[: i - self._lgt] self._extra = self._extra[: i - self._lgt]
def _calculate_index(self, i): def _calculate_index(self, i):
return self._offsets[i] return self._offsets[i]
def parse_index2(data, inline, revlogv2=False): def parse_index2(data, inline, format=revlog_constants.REVLOGV1):
if format == revlog_constants.CHANGELOGV2:
return parse_index_cl_v2(data)
if not inline: if not inline:
cls = IndexObject2 if revlogv2 else IndexObject if format == revlog_constants.REVLOGV2:
cls = IndexObject2
else:
cls = IndexObject
return cls(data), None return cls(data), None
cls = InlinedIndexObject cls = InlinedIndexObject
return cls(data, inline), (0, data) return cls(data, inline), (0, data)
def parse_index_cl_v2(data): def parse_index_cl_v2(data):
return IndexChangelogV2(data), None return IndexChangelogV2(data), None

mercurial/revlog.py

) )
# blanked usage of all the name to prevent pyflakes constraints # blanked usage of all the name to prevent pyflakes constraints
# We need these name available in the module for extensions. # We need these name available in the module for extensions.
REVLOGV0 REVLOGV0
REVLOGV1 REVLOGV1
REVLOGV2 REVLOGV2
CHANGELOGV2
FLAG_INLINE_DATA FLAG_INLINE_DATA
FLAG_GENERALDELTA FLAG_GENERALDELTA
REVLOG_DEFAULT_FLAGS REVLOG_DEFAULT_FLAGS
REVLOG_DEFAULT_FORMAT REVLOG_DEFAULT_FORMAT
REVLOG_DEFAULT_VERSION REVLOG_DEFAULT_VERSION
REVLOGV1_FLAGS REVLOGV1_FLAGS
REVLOGV2_FLAGS REVLOGV2_FLAGS
REVIDX_ISCENSORED REVIDX_ISCENSORED
def parse_index_v1(data, inline): def parse_index_v1(data, inline):
# call the C implementation to parse the index data # call the C implementation to parse the index data
index, cache = parsers.parse_index2(data, inline) index, cache = parsers.parse_index2(data, inline)
return index, cache return index, cache
def parse_index_v2(data, inline): def parse_index_v2(data, inline):
# call the C implementation to parse the index data # call the C implementation to parse the index data
index, cache = parsers.parse_index2(data, inline, revlogv2=True) index, cache = parsers.parse_index2(data, inline, format=REVLOGV2)
return index, cache return index, cache
def parse_index_cl_v2(data, inline): def parse_index_cl_v2(data, inline):
# call the C implementation to parse the index data # call the C implementation to parse the index data
assert not inline index, cache = parsers.parse_index2(data, inline, format=CHANGELOGV2)
from .pure.parsers import parse_index_cl_v2
index, cache = parse_index_cl_v2(data)
return index, cache return index, cache
if util.safehasattr(parsers, 'parse_index_devel_nodemap'): if util.safehasattr(parsers, 'parse_index_devel_nodemap'):
def parse_index_v1_nodemap(data, inline): def parse_index_v1_nodemap(data, inline):
index, cache = parsers.parse_index_devel_nodemap(data, inline) index, cache = parsers.parse_index_devel_nodemap(data, inline)
return index, cache return index, cache

tests/test-parseindex2.py

b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01F' b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01F'
b'\x13\x00\x00\x00\x00\x01\xec\x00\x00\x03\x06\x00\x00\x00\x01' b'\x13\x00\x00\x00\x00\x01\xec\x00\x00\x03\x06\x00\x00\x00\x01'
b'\x00\x00\x00\x03\x00\x00\x00\x02\xff\xff\xff\xff\x12\xcb\xeby1' b'\x00\x00\x00\x03\x00\x00\x00\x02\xff\xff\xff\xff\x12\xcb\xeby1'
b'\xb6\r\x98B\xcb\x07\xbd`\x8f\x92\xd9\xc4\x84\xbdK\x00\x00\x00' b'\xb6\r\x98B\xcb\x07\xbd`\x8f\x92\xd9\xc4\x84\xbdK\x00\x00\x00'
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00' b'\x00\x00\x00\x00\x00\x00\x00\x00\x00'
) )
def parse_index2(data, inline, revlogv2=False): def parse_index2(data, inline, format=constants.REVLOGV1):
index, chunkcache = parsers.parse_index2(data, inline, revlogv2=revlogv2) index, chunkcache = parsers.parse_index2(data, inline, format=format)
return list(index), chunkcache return list(index), chunkcache
def importparsers(hexversion): def importparsers(hexversion):
"""Import mercurial.parsers with the given sys.hexversion.""" """Import mercurial.parsers with the given sys.hexversion."""
# The file parsers.c inspects sys.hexversion to determine the version # The file parsers.c inspects sys.hexversion to determine the version
# of the currently-running Python interpreter, so we monkey-patch # of the currently-running Python interpreter, so we monkey-patch
# sys.hexversion to simulate using different versions. # sys.hexversion to simulate using different versions.