This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7314

revlog: no longer return the nodemap after parsing
ClosedPublic

Authored by marmoute on Nov 8 2019, 4:28 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGe258ad110488: revlog: no longer return the nodemap after parsing
rHG3d6507e78672: revlog: no longer return the nodemap after parsing
Summary

Now that both pure and cext version have a nodemap attribute, we do not need
to return the nodemap object after parsing.

This work is part of a refactoring to unify the revlog index and the nodemap.
This unification prepare the use of a persistent nodemap.

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.

Revision Contents
Changeset List

PathPackages
Mcontrib/perf.py (4 lines)
Mmercurial/revlog.py (8 lines)

Diff 17827

contrib/perf.py

def getentries(revs, count=1): def getentries(revs, count=1):
index = revlogio.parseindex(data, inline)[0] index = revlogio.parseindex(data, inline)[0]
for i in range(count): for i in range(count):
for rev in revs: for rev in revs:
index[rev] index[rev]
def resolvenode(node): def resolvenode(node):
nodemap = revlogio.parseindex(data, inline)[1] nodemap = getattr(revlogio.parseindex(data, inline)[0], 'nodemap', None)
# This only works for the C code. # This only works for the C code.
if nodemap is None: if nodemap is None:
return return
try: try:
nodemap[node] nodemap[node]
except error.RevlogError: except error.RevlogError:
pass pass
def resolvenodes(nodes, count=1): def resolvenodes(nodes, count=1):
nodemap = revlogio.parseindex(data, inline)[1] nodemap = getattr(revlogio.parseindex(data, inline)[0], 'nodemap', None)
if nodemap is None: if nodemap is None:
return return
for i in range(count): for i in range(count):
for node in nodes: for node in nodes:
try: try:
nodemap[node] nodemap[node]
except error.RevlogError: except error.RevlogError:

mercurial/revlog.py

nodemap.get(e[5], nullrev), nodemap.get(e[5], nullrev),
e[6], e[6],
) )
index.append(e2) index.append(e2)
nodemap[e[6]] = n nodemap[e[6]] = n
n += 1 n += 1
index = revlogoldindex(index) index = revlogoldindex(index)
return index, index.nodemap, None return index, None
def packentry(self, entry, node, version, rev): def packentry(self, entry, node, version, rev):
if gettype(entry[0]): if gettype(entry[0]):
raise error.RevlogError( raise error.RevlogError(
_(b'index entry flags need revlog version 1') _(b'index entry flags need revlog version 1')
) )
e2 = ( e2 = (
getoffset(entry[0]), getoffset(entry[0]),
class revlogio(object): class revlogio(object):
def __init__(self): def __init__(self):
self.size = indexformatng.size self.size = indexformatng.size
def parseindex(self, data, inline): def parseindex(self, 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, index.nodemap, cache return index, cache
def packentry(self, entry, node, version, rev): def packentry(self, entry, node, version, rev):
p = indexformatng_pack(*entry) p = indexformatng_pack(*entry)
if rev == 0: if rev == 0:
p = versionformat_pack(version) + p[4:] p = versionformat_pack(version) + p[4:]
return p return p
if self.version == REVLOGV0: if self.version == REVLOGV0:
self._io = revlogoldio() self._io = revlogoldio()
try: try:
d = self._io.parseindex(indexdata, self._inline) d = self._io.parseindex(indexdata, self._inline)
except (ValueError, IndexError): except (ValueError, IndexError):
raise error.RevlogError( raise error.RevlogError(
_(b"index %s is corrupted") % self.indexfile _(b"index %s is corrupted") % self.indexfile
) )
self.index, nodemap, self._chunkcache = d self.index, self._chunkcache = d
self.nodemap = self._nodecache = nodemap self.nodemap = self._nodecache = self.index.nodemap
if not self._chunkcache: if not self._chunkcache:
self._chunkclear() self._chunkclear()
# revnum -> (chain-length, sum-delta-length) # revnum -> (chain-length, sum-delta-length)
self._chaininfocache = {} self._chaininfocache = {}
# revlog header -> revlog compressor # revlog header -> revlog compressor
self._decompressors = {} self._decompressors = {}
@util.propertycache @util.propertycache