This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4162

index: don't include nullid in the internal "length" field
ClosedPublic

Authored by martinvonz on Aug 9 2018, 3:27 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG52e9bf215f96: index: don't include nullid in the internal "length" field
Summary

This is a follow-up to 781b2720d2ac (index: don't include nullid in
len(), 2018-07-20). I intentionally didn't update the "index stats",
so it will also not include the space for nullid after this patch.

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

martinvonz created this revision.Aug 9 2018, 3:27 AM
durin42 added a subscriber: durin42.Aug 9 2018, 2:25 PM

Can I interest you in adding a test for len(index) to test-parseindex2.py? I suspect we have some differences between pure and C code right now...

martinvonz added a comment.Aug 9 2018, 11:51 PM
In D4162#64736, @durin42 wrote:

Can I interest you in adding a test for len(index) to test-parseindex2.py? I suspect we have some differences between pure and C code right now...

Ah, that test is already failing. I sent D4241 to fix that. I think it already checks the length via the == operator (i.e. py_res_1 != c_res_1 would have failed if the length didn't match).

durin42 added a comment.Aug 10 2018, 1:53 AM

Reviewers may also find my series rooted at D4181 interesting.

Closed by commit rHG52e9bf215f96: index: don't include nullid in the internal "length" field (authored by martinvonz). · Explain WhyAug 12 2018, 12:45 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

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

Diff 10335

mercurial/cext/revlog.c

int ntlookups; /* # lookups */ int ntlookups; /* # lookups */
int ntmisses; /* # lookups that miss the cache */ int ntmisses; /* # lookups that miss the cache */
int inlined; int inlined;
}; };
static Py_ssize_t index_length(const indexObject *self) static Py_ssize_t index_length(const indexObject *self)
{ {
if (self->added == NULL) if (self->added == NULL)
return self->length - 1; return self->length;
return self->length + PyList_GET_SIZE(self->added) - 1; return self->length + PyList_GET_SIZE(self->added);
} }
static PyObject *nullentry; static PyObject *nullentry;
static const char nullid[20]; static const char nullid[20];
static Py_ssize_t inline_scan(indexObject *self, const char **offsets); static Py_ssize_t inline_scan(indexObject *self, const char **offsets);
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
} }
return (const char *)(self->buf.buf) + pos * v1_hdrsize; return (const char *)(self->buf.buf) + pos * v1_hdrsize;
} }
static inline int index_get_parents(indexObject *self, Py_ssize_t rev, static inline int index_get_parents(indexObject *self, Py_ssize_t rev,
int *ps, int maxrev) int *ps, int maxrev)
{ {
if (rev >= self->length - 1) { if (rev >= self->length) {
PyObject *tuple = PyList_GET_ITEM(self->added, PyObject *tuple = PyList_GET_ITEM(self->added, rev - self->length);
rev - self->length + 1);
ps[0] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 5)); ps[0] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 5));
ps[1] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 6)); ps[1] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 6));
} else { } else {
const char *data = index_deref(self, rev); const char *data = index_deref(self, rev);
ps[0] = getbe32(data + 24); ps[0] = getbe32(data + 24);
ps[1] = getbe32(data + 28); ps[1] = getbe32(data + 28);
} }
/* If index file is corrupted, ps[] may point to invalid revisions. So /* If index file is corrupted, ps[] may point to invalid revisions. So
return nullentry; return nullentry;
} }
if (pos < 0 || pos >= length) { if (pos < 0 || pos >= length) {
PyErr_SetString(PyExc_IndexError, "revlog index out of range"); PyErr_SetString(PyExc_IndexError, "revlog index out of range");
return NULL; return NULL;
} }
if (pos >= self->length - 1) { if (pos >= self->length) {
PyObject *obj; PyObject *obj;
obj = PyList_GET_ITEM(self->added, pos - self->length + 1); obj = PyList_GET_ITEM(self->added, pos - self->length);
Py_INCREF(obj); Py_INCREF(obj);
return obj; return obj;
} }
if (self->cache) { if (self->cache) {
if (self->cache[pos]) { if (self->cache[pos]) {
Py_INCREF(self->cache[pos]); Py_INCREF(self->cache[pos]);
return self->cache[pos]; return self->cache[pos];
const char *data; const char *data;
if (pos == -1) if (pos == -1)
return nullid; return nullid;
if (pos >= length) if (pos >= length)
return NULL; return NULL;
if (pos >= self->length - 1) { if (pos >= self->length) {
PyObject *tuple, *str; PyObject *tuple, *str;
tuple = PyList_GET_ITEM(self->added, pos - self->length + 1); tuple = PyList_GET_ITEM(self->added, pos - self->length);
str = PyTuple_GetItem(tuple, 7); str = PyTuple_GetItem(tuple, 7);
return str ? PyBytes_AS_STRING(str) : NULL; return str ? PyBytes_AS_STRING(str) : NULL;
} }
data = index_deref(self, pos); data = index_deref(self, pos);
return data ? data + 32 : NULL; return data ? data + 32 : NULL;
} }
t = PyInt_FromSsize_t(len); t = PyInt_FromSsize_t(len);
if (!t) if (!t)
goto bail; goto bail;
if (PyDict_SetItemString(obj, "index entries added", t) == -1) if (PyDict_SetItemString(obj, "index entries added", t) == -1)
goto bail; goto bail;
Py_DECREF(t); Py_DECREF(t);
} }
if (self->raw_length != self->length - 1) if (self->raw_length != self->length)
istat(raw_length, "revs on disk"); istat(raw_length, "revs on disk");
istat(length, "revs in memory"); istat(length, "revs in memory");
istat(ntlookups, "node trie lookups"); istat(ntlookups, "node trie lookups");
istat(ntmisses, "node trie misses"); istat(ntmisses, "node trie misses");
istat(ntrev, "node trie last rev scanned"); istat(ntrev, "node trie last rev scanned");
if (self->nt) { if (self->nt) {
istat(nt->capacity, "node trie capacity"); istat(nt->capacity, "node trie capacity");
istat(nt->depth, "node trie depth"); istat(nt->depth, "node trie depth");
* Obtain the base revision index entry. * Obtain the base revision index entry.
* *
* Callers must ensure that rev >= 0 or illegal memory access may occur. * Callers must ensure that rev >= 0 or illegal memory access may occur.
*/ */
static inline int index_baserev(indexObject *self, int rev) static inline int index_baserev(indexObject *self, int rev)
{ {
const char *data; const char *data;
if (rev >= self->length - 1) { if (rev >= self->length) {
PyObject *tuple = PyList_GET_ITEM(self->added, PyObject *tuple = PyList_GET_ITEM(self->added, rev - self->length);
rev - self->length + 1);
return (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 3)); return (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 3));
} }
else { else {
data = index_deref(self, rev); data = index_deref(self, rev);
if (data == NULL) { if (data == NULL) {
return -2; return -2;
} }
} }
if (stop != length - 1) { if (stop != length - 1) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
"revlog index deletion indices are invalid"); "revlog index deletion indices are invalid");
return -1; return -1;
} }
if (start < self->length - 1) { if (start < self->length) {
if (self->nt) { if (self->nt) {
Py_ssize_t i; Py_ssize_t i;
for (i = start + 1; i < self->length - 1; i++) { for (i = start + 1; i < self->length; i++) {
const char *node = index_node_existing(self, i); const char *node = index_node_existing(self, i);
if (node == NULL) if (node == NULL)
return -1; return -1;
nt_delete_node(self->nt, node); nt_delete_node(self->nt, node);
} }
if (self->added) if (self->added)
index_invalidate_added(self, 0); index_invalidate_added(self, 0);
if (self->ntrev > start) if (self->ntrev > start)
self->ntrev = (int)start; self->ntrev = (int)start;
} }
self->length = start + 1; self->length = start;
if (start < self->raw_length) { if (start < self->raw_length) {
if (self->cache) { if (self->cache) {
Py_ssize_t i; Py_ssize_t i;
for (i = start; i < self->raw_length; i++) for (i = start; i < self->raw_length; i++)
Py_CLEAR(self->cache[i]); Py_CLEAR(self->cache[i]);
} }
self->raw_length = start; self->raw_length = start;
} }
goto done; goto done;
} }
if (self->nt) { if (self->nt) {
index_invalidate_added(self, start - self->length + 1); index_invalidate_added(self, start - self->length);
if (self->ntrev > start) if (self->ntrev > start)
self->ntrev = (int)start; self->ntrev = (int)start;
} }
if (self->added) if (self->added)
ret = PyList_SetSlice(self->added, start - self->length + 1, ret = PyList_SetSlice(self->added, start - self->length,
PyList_GET_SIZE(self->added), NULL); PyList_GET_SIZE(self->added), NULL);
done: done:
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
return ret; return ret;
} }
/* /*
* Supported ops: * Supported ops:
self->ntrev = -1; self->ntrev = -1;
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->raw_length = len; self->raw_length = len;
self->length = len + 1; self->length = len;
} else { } else {
if (size % v1_hdrsize) { if (size % v1_hdrsize) {
PyErr_SetString(PyExc_ValueError, "corrupt index file"); PyErr_SetString(PyExc_ValueError, "corrupt index file");
goto bail; goto bail;
} }
self->raw_length = size / v1_hdrsize; self->raw_length = size / v1_hdrsize;
self->length = self->raw_length + 1; self->length = self->raw_length;
} }
return 0; return 0;
bail: bail:
return -1; return -1;
} }
static PyObject *index_nodemap(indexObject *self) static PyObject *index_nodemap(indexObject *self)