This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10566

revlog: rename `hdrsize` to `entry_size` in the C code
ClosedPublic

Authored by marmoute on May 3 2021, 7:47 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc55afa35a5c8: revlog: rename `hdrsize` to `entry_size` in the C code
Summary

This is the size of and index entry, so lets make it clearer.

Diff Detail

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

Event Timeline

marmoute created this revision.May 3 2021, 7:47 AM
baymax updated this revision to Diff 27481.May 3 2021, 9:43 PM

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

Alphare accepted this revision.May 7 2021, 8:55 AM
This revision is now accepted and ready to land.May 7 2021, 8:55 AM
marmoute added a commit: rHGc55afa35a5c8: revlog: rename `hdrsize` to `entry_size` in the C code.May 11 2021, 12:41 PM
Closed by commit rHGc55afa35a5c8: revlog: rename `hdrsize` to `entry_size` in the C code (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/revlog.c (54 lines)

Diff 27343

mercurial/cext/revlog.c

PyObject *headrevs; /* cache, invalidated on changes */ PyObject *headrevs; /* cache, invalidated on changes */
PyObject *filteredrevs; /* filtered revs set */ PyObject *filteredrevs; /* filtered revs set */
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 hdrsize; /* 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
*/
}; };
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};
static const Py_ssize_t nullrev = -1; static const Py_ssize_t nullrev = -1;
static Py_ssize_t inline_scan(indexObject *self, const char **offsets); static Py_ssize_t inline_scan(indexObject *self, const char **offsets);
static int index_find_node(indexObject *self, const char *node); static int index_find_node(indexObject *self, const char *node);
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
static const char *const v1_tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#"); static const char *const v1_tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#");
static const char *const v2_tuple_format = PY23("Kiiiiiis#Ki", "Kiiiiiiy#Ki"); static const char *const v2_tuple_format = PY23("Kiiiiiis#Ki", "Kiiiiiiy#Ki");
#else #else
static const char *const v1_tuple_format = PY23("kiiiiiis#", "kiiiiiiy#"); static const char *const v1_tuple_format = PY23("kiiiiiis#", "kiiiiiiy#");
static const char *const v2_tuple_format = PY23("kiiiiiis#ki", "kiiiiiiy#ki"); static const char *const v2_tuple_format = PY23("kiiiiiis#ki", "kiiiiiiy#ki");
#endif #endif
/* A RevlogNG v1 index entry is 64 bytes long. */ /* A RevlogNG v1 index entry is 64 bytes long. */
static const long v1_hdrsize = 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_hdrsize = 96; static const long v2_entry_size = 96;
static void raise_revlog_error(void) static void raise_revlog_error(void)
{ {
PyObject *mod = NULL, *dict = NULL, *errclass = NULL; PyObject *mod = NULL, *dict = NULL, *errclass = NULL;
mod = PyImport_ImportModule("mercurial.error"); mod = PyImport_ImportModule("mercurial.error");
if (mod == NULL) { if (mod == NULL) {
goto cleanup; goto cleanup;
} }
/* /*
* Return a pointer to the beginning of a RevlogNG record. * Return a pointer to the beginning of a RevlogNG record.
*/ */
static const char *index_deref(indexObject *self, Py_ssize_t pos) static const char *index_deref(indexObject *self, Py_ssize_t pos)
{ {
if (pos >= self->length) if (pos >= self->length)
return self->added + (pos - self->length) * self->hdrsize; return self->added + (pos - self->length) * self->entry_size;
if (self->inlined && pos > 0) { if (self->inlined && pos > 0) {
if (self->offsets == NULL) { if (self->offsets == NULL) {
Py_ssize_t ret; Py_ssize_t ret;
self->offsets = self->offsets =
PyMem_Malloc(self->length * sizeof(*self->offsets)); PyMem_Malloc(self->length * sizeof(*self->offsets));
if (self->offsets == NULL) if (self->offsets == NULL)
return (const char *)PyErr_NoMemory(); return (const char *)PyErr_NoMemory();
ret = inline_scan(self, self->offsets); ret = inline_scan(self, self->offsets);
if (ret == -1) { if (ret == -1) {
return NULL; return NULL;
}; };
} }
return self->offsets[pos]; return self->offsets[pos];
} }
return (const char *)(self->buf.buf) + pos * self->hdrsize; return (const char *)(self->buf.buf) + pos * self->entry_size;
} }
/* /*
* Get parents of the given rev. * Get parents of the given rev.
* *
* The specified rev must be valid and must not be nullrev. A returned * The specified rev must be valid and must not be nullrev. A returned
* parent revision may be nullrev, but is guaranteed to be in valid range. * parent revision may be nullrev, but is guaranteed to be in valid range.
*/ */
comp_len = getbe32(data + 8); comp_len = getbe32(data + 8);
uncomp_len = getbe32(data + 12); uncomp_len = getbe32(data + 12);
base_rev = getbe32(data + 16); base_rev = getbe32(data + 16);
link_rev = getbe32(data + 20); link_rev = getbe32(data + 20);
parent_1 = getbe32(data + 24); parent_1 = getbe32(data + 24);
parent_2 = getbe32(data + 28); parent_2 = getbe32(data + 28);
c_node_id = data + 32; c_node_id = data + 32;
if (self->hdrsize == v1_hdrsize) { if (self->entry_size == v1_entry_size) {
return Py_BuildValue(v1_tuple_format, offset_flags, comp_len, return Py_BuildValue(v1_tuple_format, offset_flags, comp_len,
uncomp_len, base_rev, link_rev, parent_1, uncomp_len, base_rev, link_rev, parent_1,
parent_2, c_node_id, self->nodelen); parent_2, c_node_id, self->nodelen);
} else { } else {
sidedata_offset = getbe64(data + 64); sidedata_offset = getbe64(data + 64);
sidedata_comp_len = getbe32(data + 72); sidedata_comp_len = getbe32(data + 72);
return Py_BuildValue(v2_tuple_format, offset_flags, comp_len, return Py_BuildValue(v2_tuple_format, offset_flags, comp_len,
return NULL; return NULL;
}; };
data = index_deref(self, rev); data = index_deref(self, rev);
if (data == NULL) if (data == NULL)
return NULL; return NULL;
if (rev == 0) { if (rev == 0) {
/* the header is eating the start of the first entry */ /* the header is eating the start of the first entry */
return PyBytes_FromStringAndSize(data + 4, self->hdrsize - 4); return PyBytes_FromStringAndSize(data + 4,
self->entry_size - 4);
} }
return PyBytes_FromStringAndSize(data, self->hdrsize); return PyBytes_FromStringAndSize(data, self->entry_size);
} }
/* /*
* Return the hash of node corresponding to the given rev. * Return the hash of node corresponding to the given rev.
*/ */
static const char *index_node(indexObject *self, Py_ssize_t pos) static const char *index_node(indexObject *self, Py_ssize_t pos)
{ {
Py_ssize_t length = index_length(self); Py_ssize_t length = index_length(self);
static PyObject *index_append(indexObject *self, PyObject *obj) static PyObject *index_append(indexObject *self, PyObject *obj)
{ {
uint64_t offset_flags, sidedata_offset; uint64_t offset_flags, sidedata_offset;
int rev, comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2; int rev, comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2;
Py_ssize_t c_node_id_len, sidedata_comp_len; Py_ssize_t c_node_id_len, sidedata_comp_len;
const char *c_node_id; const char *c_node_id;
char *data; char *data;
if (self->hdrsize == v1_hdrsize) { if (self->entry_size == v1_entry_size) {
if (!PyArg_ParseTuple(obj, v1_tuple_format, &offset_flags, if (!PyArg_ParseTuple(obj, v1_tuple_format, &offset_flags,
&comp_len, &uncomp_len, &base_rev, &comp_len, &uncomp_len, &base_rev,
&link_rev, &parent_1, &parent_2, &link_rev, &parent_1, &parent_2,
&c_node_id, &c_node_id_len)) { &c_node_id, &c_node_id_len)) {
PyErr_SetString(PyExc_TypeError, "8-tuple required"); PyErr_SetString(PyExc_TypeError, "8-tuple required");
return NULL; return NULL;
} }
} else { } else {
if (c_node_id_len != self->nodelen) { if (c_node_id_len != self->nodelen) {
PyErr_SetString(PyExc_TypeError, "invalid node"); PyErr_SetString(PyExc_TypeError, "invalid node");
return NULL; return NULL;
} }
if (self->new_length == self->added_length) { if (self->new_length == self->added_length) {
size_t new_added_length = size_t new_added_length =
self->added_length ? self->added_length * 2 : 4096; self->added_length ? self->added_length * 2 : 4096;
void *new_added = PyMem_Realloc(self->added, new_added_length * void *new_added = PyMem_Realloc(
self->hdrsize); self->added, new_added_length * self->entry_size);
if (!new_added) if (!new_added)
return PyErr_NoMemory(); return PyErr_NoMemory();
self->added = new_added; self->added = new_added;
self->added_length = new_added_length; self->added_length = new_added_length;
} }
rev = self->length + self->new_length; rev = self->length + self->new_length;
data = self->added + self->hdrsize * self->new_length++; data = self->added + self->entry_size * self->new_length++;
putbe32(offset_flags >> 32, data); putbe32(offset_flags >> 32, data);
putbe32(offset_flags & 0xffffffffU, data + 4); putbe32(offset_flags & 0xffffffffU, data + 4);
putbe32(comp_len, data + 8); putbe32(comp_len, data + 8);
putbe32(uncomp_len, data + 12); putbe32(uncomp_len, data + 12);
putbe32(base_rev, data + 16); putbe32(base_rev, data + 16);
putbe32(link_rev, data + 20); putbe32(link_rev, data + 20);
putbe32(parent_1, data + 24); putbe32(parent_1, data + 24);
putbe32(parent_2, data + 28); putbe32(parent_2, data + 28);
memcpy(data + 32, c_node_id, c_node_id_len); memcpy(data + 32, c_node_id, c_node_id_len);
/* Padding since SHA-1 is only 20 bytes for now */ /* Padding since SHA-1 is only 20 bytes for now */
memset(data + 32 + c_node_id_len, 0, 32 - c_node_id_len); memset(data + 32 + c_node_id_len, 0, 32 - c_node_id_len);
if (self->hdrsize != v1_hdrsize) { if (self->entry_size != v1_entry_size) {
putbe64(sidedata_offset, data + 64); putbe64(sidedata_offset, data + 64);
putbe32(sidedata_comp_len, data + 72); putbe32(sidedata_comp_len, data + 72);
/* Padding for 96 bytes alignment */ /* Padding for 96 bytes alignment */
memset(data + 76, 0, self->hdrsize - 76); memset(data + 76, 0, self->entry_size - 76);
} }
if (self->ntinitialized) if (self->ntinitialized)
nt_insert(&self->nt, c_node_id, rev); nt_insert(&self->nt, c_node_id, rev);
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* Replace an existing index entry's sidedata offset and length with new ones. /* Replace an existing index entry's sidedata offset and length with new ones.
This cannot be used outside of the context of sidedata rewriting, This cannot be used outside of the context of sidedata rewriting,
inside the transaction that creates the given revision. */ inside the transaction that creates the given revision. */
static PyObject *index_replace_sidedata_info(indexObject *self, PyObject *args) static PyObject *index_replace_sidedata_info(indexObject *self, PyObject *args)
{ {
uint64_t offset_flags, sidedata_offset; uint64_t offset_flags, sidedata_offset;
int rev; int rev;
Py_ssize_t sidedata_comp_len; Py_ssize_t sidedata_comp_len;
char *data; char *data;
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
const char *const sidedata_format = PY23("nKiK", "nKiK"); const char *const sidedata_format = PY23("nKiK", "nKiK");
#else #else
const char *const sidedata_format = PY23("nkik", "nkik"); const char *const sidedata_format = PY23("nkik", "nkik");
#endif #endif
if (self->hdrsize == v1_hdrsize || self->inlined) { if (self->entry_size == v1_entry_size || self->inlined) {
/* /*
There is a bug in the transaction handling when going from an There is a bug in the transaction handling when going from an
inline revlog to a separate index and data file. Turn it off until inline revlog to a separate index and data file. Turn it off until
it's fixed, since v2 revlogs sometimes get rewritten on exchange. it's fixed, since v2 revlogs sometimes get rewritten on exchange.
See issue6485. See issue6485.
*/ */
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
PyErr_SetString( PyErr_SetString(
PyExc_IndexError, PyExc_IndexError,
"cannot rewrite entries outside of this transaction"); "cannot rewrite entries outside of this transaction");
return NULL; return NULL;
} }
/* Find the newly added node, offset from the "already on-disk" length /* Find the newly added node, offset from the "already on-disk" length
*/ */
data = self->added + self->hdrsize * (rev - self->length); data = self->added + self->entry_size * (rev - self->length);
putbe64(offset_flags, data); putbe64(offset_flags, data);
putbe64(sidedata_offset, data + 64); putbe64(sidedata_offset, data + 64);
putbe32(sidedata_comp_len, data + 72); putbe32(sidedata_comp_len, data + 72);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *index_stats(indexObject *self) static PyObject *index_stats(indexObject *self)
* Find all RevlogNG entries in an index that has inline data. Update * Find all RevlogNG entries in an index that has inline data. Update
* the optional "offsets" table with those entries. * the optional "offsets" table with those entries.
*/ */
static Py_ssize_t inline_scan(indexObject *self, const char **offsets) static Py_ssize_t inline_scan(indexObject *self, const char **offsets)
{ {
const char *data = (const char *)self->buf.buf; const char *data = (const char *)self->buf.buf;
Py_ssize_t pos = 0; Py_ssize_t pos = 0;
Py_ssize_t end = self->buf.len; Py_ssize_t end = self->buf.len;
long incr = self->hdrsize; long incr = self->entry_size;
Py_ssize_t len = 0; Py_ssize_t len = 0;
while (pos + self->hdrsize <= end && pos >= 0) { while (pos + self->entry_size <= end && pos >= 0) {
uint32_t comp_len, sidedata_comp_len = 0; uint32_t comp_len, sidedata_comp_len = 0;
/* 3rd element of header is length of compressed inline data */ /* 3rd element of header is length of compressed inline data */
comp_len = getbe32(data + pos + 8); comp_len = getbe32(data + pos + 8);
if (self->hdrsize == v2_hdrsize) { if (self->entry_size == v2_entry_size) {
sidedata_comp_len = getbe32(data + pos + 72); sidedata_comp_len = getbe32(data + pos + 72);
} }
incr = self->hdrsize + comp_len + sidedata_comp_len; incr = self->entry_size + comp_len + sidedata_comp_len;
if (offsets) if (offsets)
offsets[len] = data + pos; offsets[len] = data + pos;
len++; len++;
pos += incr; pos += incr;
} }
if (pos != end) { if (pos != end) {
if (!PyErr_Occurred()) if (!PyErr_Occurred())
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 (revlogv2 && PyObject_IsTrue(revlogv2)) {
self->hdrsize = v2_hdrsize; self->entry_size = v2_entry_size;
} else { } else {
self->hdrsize = v1_hdrsize; self->entry_size = v1_entry_size;
} }
if (self->hdrsize == v1_hdrsize) { if (self->entry_size == v1_entry_size) {
self->nullentry = self->nullentry =
Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, -1, Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, -1,
-1, -1, -1, nullid, self->nodelen); -1, -1, -1, nullid, self->nodelen);
} else { } else {
self->nullentry = self->nullentry =
Py_BuildValue(PY23("iiiiiiis#ii", "iiiiiiiy#ii"), 0, 0, 0, Py_BuildValue(PY23("iiiiiiis#ii", "iiiiiiiy#ii"), 0, 0, 0,
-1, -1, -1, -1, nullid, self->nodelen, 0, 0); -1, -1, -1, -1, nullid, self->nodelen, 0, 0);
} }
Py_INCREF(self->data); Py_INCREF(self->data);
if (self->inlined) { if (self->inlined) {
Py_ssize_t len = inline_scan(self, NULL); Py_ssize_t len = inline_scan(self, NULL);
if (len == -1) if (len == -1)
goto bail; goto bail;
self->length = len; self->length = len;
} else { } else {
if (size % self->hdrsize) { if (size % self->entry_size) {
PyErr_SetString(PyExc_ValueError, "corrupt index file"); PyErr_SetString(PyExc_ValueError, "corrupt index file");
goto bail; goto bail;
} }
self->length = size / self->hdrsize; self->length = size / self->entry_size;
} }
return 0; return 0;
bail: bail:
return -1; return -1;
} }
static PyObject *index_nodemap(indexObject *self) static PyObject *index_nodemap(indexObject *self)
}; };
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, hdrsize), 0, {"entry_size", T_LONG, offsetof(indexObject, entry_size), 0,
"size of an index entry"}, "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 */