comparison mercurial/cext/revlog.c @ 38914:f28e64bbdd29

index: drop now-redundant "nt" prefix of fields in nodetree struct

Differential Revision: https://phab.mercurial-scm.org/D4110

38913:c2c253558e3c

 * Negative value is a leaf: -(rev + 2)
 * Zero is empty
 */
typedef struct {
	nodetreenode *nodes;
	unsigned ntlength;     /* # nodes in use */
	unsigned ntcapacity;   /* # nodes allocated */
	int ntdepth;           /* maximum depth of tree */
	int ntsplits;          /* # splits performed */
} nodetree;

/*
 * This class has two behaviors.
 *

	istat(length, "revs in memory");
	istat(ntlookups, "node trie lookups");
	istat(ntmisses, "node trie misses");
	istat(ntrev, "node trie last rev scanned");
	if (self->nt) {
		istat(nt->ntcapacity, "node trie capacity");
		istat(nt->ntdepth, "node trie depth");
		istat(nt->ntlength, "node trie count");
		istat(nt->ntsplits, "node trie splits");
	}

#undef istat

	return obj;

}

static int nt_new(indexObject *self)
{
	nodetree *nt = self->nt;
	if (nt->ntlength == nt->ntcapacity) {
		if (nt->ntcapacity >= INT_MAX / (sizeof(nodetreenode) * 2)) {
			PyErr_SetString(PyExc_MemoryError,
					"overflow in nt_new");
			return -1;
		}
		nt->ntcapacity *= 2;
		nt->nodes = realloc(nt->nodes,
				    nt->ntcapacity * sizeof(nodetreenode));
		if (nt->nodes == NULL) {
			PyErr_SetString(PyExc_MemoryError, "out of memory");
			return -1;
		}
		memset(&nt->nodes[nt->ntlength], 0,
		       sizeof(nodetreenode) * (nt->ntcapacity - nt->ntlength));
	}
	return nt->ntlength++;
}

static int nt_insert(indexObject *self, const char *node, int rev)
{
	int level = 0;

			/* self->nt->nodes may have been changed by realloc */
			self->nt->nodes[off].children[k] = noff;
			off = noff;
			n = &self->nt->nodes[off];
			n->children[nt_level(oldnode, ++level)] = v;
			if (level > self->nt->ntdepth)
				self->nt->ntdepth = level;
			self->nt->ntsplits += 1;
		} else {
			level += 1;
			off = v;
		}
	}

		}
		if ((size_t)self->raw_length > INT_MAX / sizeof(nodetreenode)) {
			PyErr_SetString(PyExc_ValueError, "overflow in nt_init");
			return -1;
		}
		self->nt->ntcapacity = self->raw_length < 4
			? 4 : (int)self->raw_length / 2;

		self->nt->nodes = calloc(self->nt->ntcapacity, sizeof(nodetreenode));
		if (self->nt->nodes == NULL) {
			free(self->nt);
			self->nt = NULL;
			PyErr_NoMemory();
			return -1;
		}
		self->ntrev = (int)index_length(self);
		self->ntlookups = 1;
		self->ntmisses = 0;
		self->nt->ntdepth = 0;
		self->nt->ntsplits = 0;
		self->nt->ntlength = 1;
		if (nt_insert(self, nullid, -1) == -1) {
			free(self->nt->nodes);
			free(self->nt);
			self->nt = NULL;
			return -1;

38914:f28e64bbdd29

 * Negative value is a leaf: -(rev + 2)
 * Zero is empty
 */
typedef struct {
	nodetreenode *nodes;
	unsigned length;     /* # nodes in use */
	unsigned capacity;   /* # nodes allocated */
	int depth;           /* maximum depth of tree */
	int splits;          /* # splits performed */
} nodetree;

/*
 * This class has two behaviors.
 *

	istat(length, "revs in memory");
	istat(ntlookups, "node trie lookups");
	istat(ntmisses, "node trie misses");
	istat(ntrev, "node trie last rev scanned");
	if (self->nt) {
		istat(nt->capacity, "node trie capacity");
		istat(nt->depth, "node trie depth");
		istat(nt->length, "node trie count");
		istat(nt->splits, "node trie splits");
	}

#undef istat

	return obj;

}

static int nt_new(indexObject *self)
{
	nodetree *nt = self->nt;
	if (nt->length == nt->capacity) {
		if (nt->capacity >= INT_MAX / (sizeof(nodetreenode) * 2)) {
			PyErr_SetString(PyExc_MemoryError,
					"overflow in nt_new");
			return -1;
		}
		nt->capacity *= 2;
		nt->nodes = realloc(nt->nodes,
				    nt->capacity * sizeof(nodetreenode));
		if (nt->nodes == NULL) {
			PyErr_SetString(PyExc_MemoryError, "out of memory");
			return -1;
		}
		memset(&nt->nodes[nt->length], 0,
		       sizeof(nodetreenode) * (nt->capacity - nt->length));
	}
	return nt->length++;
}

static int nt_insert(indexObject *self, const char *node, int rev)
{
	int level = 0;

			/* self->nt->nodes may have been changed by realloc */
			self->nt->nodes[off].children[k] = noff;
			off = noff;
			n = &self->nt->nodes[off];
			n->children[nt_level(oldnode, ++level)] = v;
			if (level > self->nt->depth)
				self->nt->depth = level;
			self->nt->splits += 1;
		} else {
			level += 1;
			off = v;
		}
	}

		}
		if ((size_t)self->raw_length > INT_MAX / sizeof(nodetreenode)) {
			PyErr_SetString(PyExc_ValueError, "overflow in nt_init");
			return -1;
		}
		self->nt->capacity = self->raw_length < 4
			? 4 : (int)self->raw_length / 2;

		self->nt->nodes = calloc(self->nt->capacity, sizeof(nodetreenode));
		if (self->nt->nodes == NULL) {
			free(self->nt);
			self->nt = NULL;
			PyErr_NoMemory();
			return -1;
		}
		self->ntrev = (int)index_length(self);
		self->ntlookups = 1;
		self->ntmisses = 0;
		self->nt->depth = 0;
		self->nt->splits = 0;
		self->nt->length = 1;
		if (nt_insert(self, nullid, -1) == -1) {
			free(self->nt->nodes);
			free(self->nt);
			self->nt = NULL;
			return -1;