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

Revision Contents
Changeset List

Diff 32178

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.