This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4372

index: embed nodetree in index object to avoid reference cycle
ClosedPublic

Authored by martinvonz on Aug 24 2018, 12:23 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG9f097214fbf3: index: embed nodetree in index object to avoid reference cycle
Summary

Since the index has a reference to a nodetree and the nodetree has a
reference back to the index, there is a reference cycle, so the index
(and its nodetree) can never be freed. This patch fixes that by making
"nodetree" a plan C struct that the index can embed, and also
introduces a new "nodetreeObject" that is a Python type wrapping the
nodetree struct.

Thanks to Yuya for noticing this and for suggesting the solution.

All tests passed on the first attempt once it compiled (I guess C is
like Haskell in this regard?).

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 24 2018, 12:23 PM
yuja added a subscriber: yuja.Aug 25 2018, 5:35 AM

-static int nt_init_py(nodetree *self, PyObject *args)
+static int ntobj_init(nodetreeObject *self, PyObject *args)
{

	PyObject *index;
	unsigned capacity;

+ int ret;

	if (!PyArg_ParseTuple(args, "O!I", &indexType, &index, &capacity))
		return -1;
  • return nt_init(self, (indexObject*)index, capacity);

+ ret = nt_init(&self->nt, (indexObject*)index, capacity);
+ if (ret == 0) {
+ Py_INCREF(index);
+ }

Perhaps index should be increfed no matter if nt_init() succeeds or not,
since the self is ntobj_dealloc()-ed anyway.

martinvonz updated this revision to Diff 10601.Aug 27 2018, 1:12 PM
martinvonz added a comment.Aug 27 2018, 1:12 PM
In D4372#67157, @yuja wrote:

-static int nt_init_py(nodetree *self, PyObject *args)
+static int ntobj_init(nodetreeObject *self, PyObject *args)
{

	PyObject *index;
	unsigned capacity;

+ int ret;

	if (!PyArg_ParseTuple(args, "O!I", &indexType, &index, &capacity))
		return -1;
  • return nt_init(self, (indexObject*)index, capacity);

+ ret = nt_init(&self->nt, (indexObject*)index, capacity);
+ if (ret == 0) {
+ Py_INCREF(index);
+ }

Perhaps index should be increfed no matter if nt_init() succeeds or not,
since the self is ntobj_dealloc()-ed anyway.

Good catch. Fixed.

Closed by commit rHG9f097214fbf3: index: embed nodetree in index object to avoid reference cycle (authored by martinvonz). · Explain WhyAug 27 2018, 6:52 PM
This revision was automatically updated to reflect the committed changes.
mharbison72 added a subscriber: mharbison72.Sep 3 2018, 11:42 PM

I haven't had time to dig into this, but I bisected a hard crash back to here on Windows.

--- c:/Users/Matt/projects/hg/tests/test-revisions.t
+++ c:/Users/Matt/projects/hg/tests/test-revisions.t.err
@@ -40,6 +40,6 @@
   [255]
 7b is no longer ambiguous
   $ hg l -r 7b
-  3:7b
+  [5]

   $ cd ..

@ has an earlier failure too, so possibly it's random-ish.

--- c:/Users/Matt/projects/hg/tests/test-revisions.t
+++ c:/Users/Matt/projects/hg/tests/test-revisions.t.err
@@ -31,6 +31,7 @@
   2:72
   1:9
   0:b
+  [5]
 9 was unambiguous and still is
   $ hg l -r 9
   1:9
@@ -40,6 +41,6 @@
   [255]
 7b is no longer ambiguous
   $ hg l -r 7b
-  3:7b
+  [5]

   $ cd ..

Revision Contents
Changeset List

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

Diff 10612

mercurial/cext/revlog.c

/* /*
* A base-16 trie for fast node->rev mapping. * A base-16 trie for fast node->rev mapping.
* *
* Positive value is index of the next node in the trie * Positive value is index of the next node in the trie
* Negative value is a leaf: -(rev + 2) * Negative value is a leaf: -(rev + 2)
* Zero is empty * Zero is empty
*/ */
typedef struct { typedef struct {
PyObject_HEAD
indexObject *index; indexObject *index;
nodetreenode *nodes; nodetreenode *nodes;
unsigned length; /* # nodes in use */ unsigned length; /* # nodes in use */
unsigned capacity; /* # nodes allocated */ unsigned capacity; /* # nodes allocated */
int depth; /* maximum depth of tree */ int depth; /* maximum depth of tree */
int splits; /* # splits performed */ int splits; /* # splits performed */
} nodetree; } nodetree;
typedef struct {
PyObject_HEAD
nodetree nt;
} nodetreeObject;
/* /*
* This class has two behaviors. * This class has two behaviors.
* *
* When used in a list-like way (with integer keys), we decode an * When used in a list-like way (with integer keys), we decode an
* entry in a RevlogNG index file on demand. Our last entry is a * entry in a RevlogNG index file on demand. Our last entry is a
* sentinel, always a nullid. We have limited support for * sentinel, always a nullid. We have limited support for
* integer-keyed insert and delete, only at elements right before the * integer-keyed insert and delete, only at elements right before the
* sentinel. * sentinel.
* *
* With string keys, we lazily perform a reverse mapping from node to * With string keys, we lazily perform a reverse mapping from node to
* rev, using a base-16 trie. * rev, using a base-16 trie.
*/ */
struct indexObjectStruct { struct indexObjectStruct {
PyObject_HEAD PyObject_HEAD
/* Type-specific fields go here. */ /* Type-specific fields go here. */
PyObject *data; /* raw bytes of index */ PyObject *data; /* raw bytes of index */
Py_buffer buf; /* buffer of data */ Py_buffer buf; /* buffer of data */
PyObject **cache; /* cached tuples */ PyObject **cache; /* cached tuples */
const char **offsets; /* populated on demand */ const char **offsets; /* populated on demand */
Py_ssize_t raw_length; /* original number of elements */ Py_ssize_t raw_length; /* original number of elements */
Py_ssize_t length; /* current number of elements */ Py_ssize_t length; /* current number of elements */
PyObject *added; /* populated on demand */ PyObject *added; /* populated on demand */
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 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;
}; };
static Py_ssize_t index_length(const indexObject *self) static Py_ssize_t index_length(const indexObject *self)
{ {
self->added = PyList_New(0); self->added = PyList_New(0);
if (self->added == NULL) if (self->added == NULL)
return NULL; return NULL;
} }
if (PyList_Append(self->added, obj) == -1) if (PyList_Append(self->added, obj) == -1)
return NULL; return NULL;
if (self->nt) if (self->ntinitialized)
nt_insert(self->nt, node, (int)len); nt_insert(&self->nt, node, (int)len);
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *index_stats(indexObject *self) static PyObject *index_stats(indexObject *self)
{ {
PyObject *obj = PyDict_New(); PyObject *obj = PyDict_New();
} }
if (self->raw_length != self->length) 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->ntinitialized) {
istat(nt->capacity, "node trie capacity"); istat(nt.capacity, "node trie capacity");
istat(nt->depth, "node trie depth"); istat(nt.depth, "node trie depth");
istat(nt->length, "node trie count"); istat(nt.length, "node trie count");
istat(nt->splits, "node trie splits"); istat(nt.splits, "node trie splits");
} }
#undef istat #undef istat
return obj; return obj;
bail: bail:
Py_XDECREF(obj); Py_XDECREF(obj);
level += 1; level += 1;
off = v; off = v;
} }
} }
return -1; return -1;
} }
static PyObject *nt_insert_py(nodetree *self, PyObject *args) static PyObject *ntobj_insert(nodetreeObject *self, PyObject *args)
{ {
Py_ssize_t rev; Py_ssize_t rev;
const char *node; const char *node;
Py_ssize_t length; Py_ssize_t length;
if (!PyArg_ParseTuple(args, "n", &rev)) if (!PyArg_ParseTuple(args, "n", &rev))
return NULL; return NULL;
length = index_length(self->index); length = index_length(self->nt.index);
if (rev < 0 || rev >= length) { if (rev < 0 || rev >= length) {
PyErr_SetString(PyExc_ValueError, "revlog index out of range"); PyErr_SetString(PyExc_ValueError, "revlog index out of range");
return NULL; return NULL;
} }
node = index_node_existing(self->index, rev); node = index_node_existing(self->nt.index, rev);
if (nt_insert(self, node, (int)rev) == -1) if (nt_insert(&self->nt, node, (int)rev) == -1)
return NULL; return NULL;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static int nt_delete_node(nodetree *self, const char *node) static int nt_delete_node(nodetree *self, const char *node)
{ {
/* rev==-2 happens to get encoded as 0, which is interpreted as not set */ /* rev==-2 happens to get encoded as 0, which is interpreted as not set */
return nt_insert(self, node, -2); return nt_insert(self, node, -2);
} }
static int nt_init(nodetree *self, indexObject *index, unsigned capacity) static int nt_init(nodetree *self, indexObject *index, unsigned capacity)
{ {
/* Initialize before overflow-checking to avoid nt_dealloc() crash. */ /* Initialize before overflow-checking to avoid nt_dealloc() crash. */
self->nodes = NULL; self->nodes = NULL;
self->index = index; self->index = index;
Py_INCREF(index);
/* The input capacity is in terms of revisions, while the field is in /* The input capacity is in terms of revisions, while the field is in
* terms of nodetree nodes. */ * terms of nodetree nodes. */
self->capacity = (capacity < 4 ? 4 : capacity / 2); self->capacity = (capacity < 4 ? 4 : capacity / 2);
self->depth = 0; self->depth = 0;
self->splits = 0; self->splits = 0;
if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) { if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) {
PyErr_SetString(PyExc_ValueError, "overflow in init_nt"); PyErr_SetString(PyExc_ValueError, "overflow in init_nt");
return -1; return -1;
} }
self->nodes = calloc(self->capacity, sizeof(nodetreenode)); self->nodes = calloc(self->capacity, sizeof(nodetreenode));
if (self->nodes == NULL) { if (self->nodes == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
return -1; return -1;
} }
self->length = 1; self->length = 1;
return 0; return 0;
} }
static PyTypeObject indexType; static PyTypeObject indexType;
static int nt_init_py(nodetree *self, PyObject *args) static int ntobj_init(nodetreeObject *self, PyObject *args)
{ {
PyObject *index; PyObject *index;
unsigned capacity; unsigned capacity;
if (!PyArg_ParseTuple(args, "O!I", &indexType, &index, &capacity)) if (!PyArg_ParseTuple(args, "O!I", &indexType, &index, &capacity))
return -1; return -1;
return nt_init(self, (indexObject*)index, capacity); Py_INCREF(index);
return nt_init(&self->nt, (indexObject*)index, capacity);
} }
static int nt_partialmatch(nodetree *self, const char *node, static int nt_partialmatch(nodetree *self, const char *node,
Py_ssize_t nodelen) Py_ssize_t nodelen)
{ {
return nt_find(self, node, nodelen, 1); return nt_find(self, node, nodelen, 1);
} }
* The node was still not unique after 40 hex digits, so this won't * The node was still not unique after 40 hex digits, so this won't
* happen. Also, if we get here, then there's a programming error in * happen. Also, if we get here, then there's a programming error in
* this file that made us insert a node longer than 40 hex digits. * this file that made us insert a node longer than 40 hex digits.
*/ */
PyErr_SetString(PyExc_Exception, "broken node tree"); PyErr_SetString(PyExc_Exception, "broken node tree");
return -3; return -3;
} }
static PyObject *nt_shortest_py(nodetree *self, PyObject *args) static PyObject *ntobj_shortest(nodetreeObject *self, PyObject *args)
{ {
PyObject *val; PyObject *val;
char *node; char *node;
int length; int length;
if (!PyArg_ParseTuple(args, "O", &val)) if (!PyArg_ParseTuple(args, "O", &val))
return NULL; return NULL;
if (node_check(val, &node) == -1) if (node_check(val, &node) == -1)
return NULL; return NULL;
length = nt_shortest(self, node); length = nt_shortest(&self->nt, node);
if (length == -3) if (length == -3)
return NULL; return NULL;
if (length == -2) { if (length == -2) {
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
} }
return PyInt_FromLong(length); return PyInt_FromLong(length);
} }
static void nt_dealloc(nodetree *self) static void nt_dealloc(nodetree *self)
{ {
Py_XDECREF(self->index);
free(self->nodes); free(self->nodes);
self->nodes = NULL; self->nodes = NULL;
}
static void ntobj_dealloc(nodetreeObject *self)
{
Py_XDECREF(self->nt.index);
nt_dealloc(&self->nt);
PyObject_Del(self); PyObject_Del(self);
} }
static PyMethodDef nt_methods[] = { static PyMethodDef ntobj_methods[] = {
{"insert", (PyCFunction)nt_insert_py, METH_VARARGS, {"insert", (PyCFunction)ntobj_insert, METH_VARARGS,
"insert an index entry"}, "insert an index entry"},
{"shortest", (PyCFunction)nt_shortest_py, METH_VARARGS, {"shortest", (PyCFunction)ntobj_shortest, METH_VARARGS,
"find length of shortest hex nodeid of a binary ID"}, "find length of shortest hex nodeid of a binary ID"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyTypeObject nodetreeType = { static PyTypeObject nodetreeType = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"parsers.nodetree", /* tp_name */ "parsers.nodetree", /* tp_name */
sizeof(nodetree) , /* tp_basicsize */ sizeof(nodetree) , /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)nt_dealloc, /* tp_dealloc */ (destructor)ntobj_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
0, /* tp_setattr */ 0, /* tp_setattr */
0, /* tp_compare */ 0, /* tp_compare */
0, /* tp_repr */ 0, /* tp_repr */
0, /* tp_as_number */ 0, /* tp_as_number */
0, /* tp_as_sequence */ 0, /* tp_as_sequence */
0, /* tp_as_mapping */ 0, /* tp_as_mapping */
0, /* tp_hash */ 0, /* tp_hash */
0, /* tp_call */ 0, /* tp_call */
0, /* tp_str */ 0, /* tp_str */
0, /* tp_getattro */ 0, /* tp_getattro */
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */ Py_TPFLAGS_DEFAULT, /* tp_flags */
"nodetree", /* tp_doc */ "nodetree", /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
nt_methods, /* tp_methods */ ntobj_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ 0, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)nt_init_py, /* tp_init */ (initproc)ntobj_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
}; };
static int index_init_nt(indexObject *self) static int index_init_nt(indexObject *self)
{ {
if (self->nt == NULL) { if (!self->ntinitialized) {
self->nt = PyObject_New(nodetree, &nodetreeType); if (nt_init(&self->nt, self, (int)self->raw_length) == -1) {
if (self->nt == NULL) { nt_dealloc(&self->nt);
return -1;
}
if (nt_init(self->nt, self, (int)self->raw_length) == -1) {
nt_dealloc(self->nt);
self->nt = NULL;
return -1; return -1;
} }
if (nt_insert(self->nt, nullid, -1) == -1) { if (nt_insert(&self->nt, nullid, -1) == -1) {
nt_dealloc(self->nt); nt_dealloc(&self->nt);
self->nt = NULL;
return -1; return -1;
} }
self->ntinitialized = 1;
self->ntrev = (int)index_length(self); self->ntrev = (int)index_length(self);
self->ntlookups = 1; self->ntlookups = 1;
self->ntmisses = 0; self->ntmisses = 0;
} }
return 0; return 0;
} }
/* /*
* Return values: * Return values:
* *
* -3: error (exception set) * -3: error (exception set)
* -2: not found (no exception set) * -2: not found (no exception set)
* rest: valid rev * rest: valid rev
*/ */
static int index_find_node(indexObject *self, static int index_find_node(indexObject *self,
const char *node, Py_ssize_t nodelen) const char *node, Py_ssize_t nodelen)
{ {
int rev; int rev;
if (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
return -3; return -3;
self->ntlookups++; self->ntlookups++;
rev = nt_find(self->nt, node, nodelen, 0); rev = nt_find(&self->nt, node, nodelen, 0);
if (rev >= -1) if (rev >= -1)
return rev; return rev;
/* /*
* For the first handful of lookups, we scan the entire index, * For the first handful of lookups, we scan the entire index,
* and cache only the matching nodes. This optimizes for cases * and cache only the matching nodes. This optimizes for cases
* like "hg tip", where only a few nodes are accessed. * like "hg tip", where only a few nodes are accessed.
* *
* After that, we cache every node we visit, using a single * After that, we cache every node we visit, using a single
* scan amortized over multiple lookups. This gives the best * scan amortized over multiple lookups. This gives the best
* bulk performance, e.g. for "hg log". * bulk performance, e.g. for "hg log".
*/ */
if (self->ntmisses++ < 4) { if (self->ntmisses++ < 4) {
for (rev = self->ntrev - 1; rev >= 0; rev--) { for (rev = self->ntrev - 1; rev >= 0; rev--) {
const char *n = index_node_existing(self, rev); const char *n = index_node_existing(self, rev);
if (n == NULL) if (n == NULL)
return -3; return -3;
if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) { if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) {
if (nt_insert(self->nt, n, rev) == -1) if (nt_insert(&self->nt, n, rev) == -1)
return -3; return -3;
break; break;
} }
} }
} else { } else {
for (rev = self->ntrev - 1; rev >= 0; rev--) { for (rev = self->ntrev - 1; rev >= 0; rev--) {
const char *n = index_node_existing(self, rev); const char *n = index_node_existing(self, rev);
if (n == NULL) if (n == NULL)
return -3; return -3;
if (nt_insert(self->nt, n, rev) == -1) { if (nt_insert(&self->nt, n, rev) == -1) {
self->ntrev = rev + 1; self->ntrev = rev + 1;
return -3; return -3;
} }
if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) { if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) {
break; break;
} }
} }
self->ntrev = rev; self->ntrev = rev;
*/ */
static int index_populate_nt(indexObject *self) { static int index_populate_nt(indexObject *self) {
int rev; int rev;
if (self->ntrev > 0) { if (self->ntrev > 0) {
for (rev = self->ntrev - 1; rev >= 0; rev--) { for (rev = self->ntrev - 1; rev >= 0; rev--) {
const char *n = index_node_existing(self, rev); const char *n = index_node_existing(self, rev);
if (n == NULL) if (n == NULL)
return -1; return -1;
if (nt_insert(self->nt, n, rev) == -1) if (nt_insert(&self->nt, n, rev) == -1)
return -1; return -1;
} }
self->ntrev = -1; self->ntrev = -1;
} }
return 0; return 0;
} }
static PyObject *index_partialmatch(indexObject *self, PyObject *args) static PyObject *index_partialmatch(indexObject *self, PyObject *args)
PyErr_Clear(); PyErr_Clear();
Py_RETURN_NONE; Py_RETURN_NONE;
} }
if (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
return NULL; return NULL;
if (index_populate_nt(self) == -1) if (index_populate_nt(self) == -1)
return NULL; return NULL;
rev = nt_partialmatch(self->nt, node, nodelen); rev = nt_partialmatch(&self->nt, node, nodelen);
switch (rev) { switch (rev) {
case -4: case -4:
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
case -2: case -2:
Py_RETURN_NONE; Py_RETURN_NONE;
case -1: case -1:
if (node_check(val, &node) == -1) if (node_check(val, &node) == -1)
return NULL; return NULL;
self->ntlookups++; self->ntlookups++;
if (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
return NULL; return NULL;
if (index_populate_nt(self) == -1) if (index_populate_nt(self) == -1)
return NULL; return NULL;
length = nt_shortest(self->nt, node); length = nt_shortest(&self->nt, node);
if (length == -3) if (length == -3)
return NULL; return NULL;
if (length == -2) { if (length == -2) {
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
} }
return PyInt_FromLong(length); return PyInt_FromLong(length);
} }
static void index_invalidate_added(indexObject *self, Py_ssize_t start) static void index_invalidate_added(indexObject *self, Py_ssize_t start)
{ {
Py_ssize_t i, len = PyList_GET_SIZE(self->added); Py_ssize_t i, len = PyList_GET_SIZE(self->added);
for (i = start; i < len; i++) { for (i = start; i < len; i++) {
PyObject *tuple = PyList_GET_ITEM(self->added, i); PyObject *tuple = PyList_GET_ITEM(self->added, i);
PyObject *node = PyTuple_GET_ITEM(tuple, 7); PyObject *node = PyTuple_GET_ITEM(tuple, 7);
nt_delete_node(self->nt, PyBytes_AS_STRING(node)); nt_delete_node(&self->nt, PyBytes_AS_STRING(node));
} }
if (start == 0) if (start == 0)
Py_CLEAR(self->added); Py_CLEAR(self->added);
} }
/* /*
* Delete a numeric range of revs, which must be at the end of the * Delete a numeric range of revs, which must be at the end of the
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) { if (start < self->length) {
if (self->nt) { if (self->ntinitialized) {
Py_ssize_t i; Py_ssize_t i;
for (i = start + 1; i < self->length; 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; 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->ntinitialized) {
index_invalidate_added(self, start - self->length); 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, ret = PyList_SetSlice(self->added, start - self->length,
PyList_GET_SIZE(self->added), NULL); PyList_GET_SIZE(self->added), NULL);
done: done:
if (PySlice_Check(item) && value == NULL) if (PySlice_Check(item) && value == NULL)
return index_slice_del(self, item); return index_slice_del(self, item);
if (node_check(item, &node) == -1) if (node_check(item, &node) == -1)
return -1; return -1;
if (value == NULL) if (value == NULL)
return self->nt ? nt_delete_node(self->nt, node) : 0; return self->ntinitialized ? nt_delete_node(&self->nt, node) : 0;
rev = PyInt_AsLong(value); rev = PyInt_AsLong(value);
if (rev > INT_MAX || rev < 0) { if (rev > INT_MAX || rev < 0) {
if (!PyErr_Occurred()) if (!PyErr_Occurred())
PyErr_SetString(PyExc_ValueError, "rev out of range"); PyErr_SetString(PyExc_ValueError, "rev out of range");
return -1; return -1;
} }
if (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
return -1; return -1;
return nt_insert(self->nt, node, (int)rev); return nt_insert(&self->nt, node, (int)rev);
} }
/* /*
* 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)
{ {
self->raw_length = 0; self->raw_length = 0;
self->added = NULL; self->added = NULL;
self->cache = NULL; self->cache = NULL;
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->nt = NULL; self->ntinitialized = 0;
self->offsets = NULL; self->offsets = NULL;
if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj)) if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj))
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;
Py_CLEAR(self->cache[i]); Py_CLEAR(self->cache[i]);
free(self->cache); free(self->cache);
self->cache = NULL; self->cache = NULL;
} }
if (self->offsets) { if (self->offsets) {
PyMem_Free((void *)self->offsets); PyMem_Free((void *)self->offsets);
self->offsets = NULL; self->offsets = NULL;
} }
if (self->nt != NULL) { if (self->ntinitialized) {
nt_dealloc(self->nt); nt_dealloc(&self->nt);
} }
self->nt = NULL; self->ntinitialized = 0;
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
} }
static PyObject *index_clearcaches(indexObject *self) static PyObject *index_clearcaches(indexObject *self)
{ {
_index_clearcaches(self); _index_clearcaches(self);
self->ntrev = -1; self->ntrev = -1;
self->ntlookups = self->ntmisses = 0; self->ntlookups = self->ntmisses = 0;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static void index_dealloc(indexObject *self) static void index_dealloc(indexObject *self)
{ {
_index_clearcaches(self); _index_clearcaches(self);
Py_XDECREF(self->filteredrevs); Py_XDECREF(self->filteredrevs);
if (self->buf.buf) { if (self->buf.buf) {
PyBuffer_Release(&self->buf); PyBuffer_Release(&self->buf);
memset(&self->buf, 0, sizeof(self->buf)); memset(&self->buf, 0, sizeof(self->buf));
} }
Py_XDECREF(self->data); Py_XDECREF(self->data);
Py_XDECREF(self->added); Py_XDECREF(self->added);
Py_XDECREF(self->nt);
PyObject_Del(self); PyObject_Del(self);
} }
static PySequenceMethods index_sequence_methods = { static PySequenceMethods index_sequence_methods = {
(lenfunc)index_length, /* sq_length */ (lenfunc)index_length, /* sq_length */
0, /* sq_concat */ 0, /* sq_concat */
0, /* sq_repeat */ 0, /* sq_repeat */
(ssizeargfunc)index_get, /* sq_item */ (ssizeargfunc)index_get, /* sq_item */