This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10509

revlog: remove the revlogio class
ClosedPublic

Authored by marmoute on Apr 23 2021, 10:29 AM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHG5e64c93d5f94: revlog: remove the revlogio class
rHG8f70a5b0cff0: revlog: remove the revlogio class
Summary

The class only contains a single parseindex method. Lets just make it a function and remove the revlogio class. It served us well but became thinner and thinner overtime

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

marmoute created this revision.Apr 23 2021, 10:29 AM
Alphare accepted this revision.Apr 29 2021, 10:37 AM
This revision is now accepted and ready to land.Apr 29 2021, 10:37 AM
pulkit added a subscriber: pulkit.Apr 30 2021, 5:47 AM
pulkit added inline comments.
mercurial/cext/revlog.c
370 ↗(On Diff #27158)

unrelated change?

marmoute added inline comments.Apr 30 2021, 6:17 AM
mercurial/cext/revlog.c
370 ↗(On Diff #27158)

I suspect clang format did it ?

marmoute added a commit: rHG8f70a5b0cff0: revlog: remove the revlogio class.May 2 2021, 6:32 PM
Closed by commit rHG8f70a5b0cff0: revlog: remove the revlogio class (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mcontrib/perf.py (23 lines)
Mmercurial/revlog.py (136 lines)

Diff 27275

contrib/perf.py

opener = getattr(rl, 'opener') # trick linter opener = getattr(rl, 'opener') # trick linter
indexfile = rl.indexfile indexfile = rl.indexfile
data = opener.read(indexfile) data = opener.read(indexfile)
header = struct.unpack(b'>I', data[0:4])[0] header = struct.unpack(b'>I', data[0:4])[0]
version = header & 0xFFFF version = header & 0xFFFF
if version == 1: if version == 1:
revlogio = revlog.revlogio()
inline = header & (1 << 16) inline = header & (1 << 16)
else: else:
raise error.Abort(b'unsupported revlog version: %d' % version) raise error.Abort(b'unsupported revlog version: %d' % version)
parse_index_v1 = getattr(revlog, 'parse_index_v1', None)
if parse_index_v1 is None:
parse_index_v1 = revlog.revlogio().parseindex
rllen = len(rl) rllen = len(rl)
node0 = rl.node(0) node0 = rl.node(0)
node25 = rl.node(rllen // 4) node25 = rl.node(rllen // 4)
node50 = rl.node(rllen // 2) node50 = rl.node(rllen // 2)
node75 = rl.node(rllen // 4 * 3) node75 = rl.node(rllen // 4 * 3)
node100 = rl.node(rllen - 1) node100 = rl.node(rllen - 1)
allrevs = range(rllen) allrevs = range(rllen)
allrevsrev = list(reversed(allrevs)) allrevsrev = list(reversed(allrevs))
allnodes = [rl.node(rev) for rev in range(rllen)] allnodes = [rl.node(rev) for rev in range(rllen)]
allnodesrev = list(reversed(allnodes)) allnodesrev = list(reversed(allnodes))
def constructor(): def constructor():
revlog.revlog(opener, indexfile) revlog.revlog(opener, indexfile)
def read(): def read():
with opener(indexfile) as fh: with opener(indexfile) as fh:
fh.read() fh.read()
def parseindex(): def parseindex():
revlogio.parseindex(data, inline) parse_index_v1(data, inline)
def getentry(revornode): def getentry(revornode):
index = revlogio.parseindex(data, inline)[0] index = parse_index_v1(data, inline)[0]
index[revornode] index[revornode]
def getentries(revs, count=1): def getentries(revs, count=1):
index = revlogio.parseindex(data, inline)[0] index = parse_index_v1(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):
index = revlogio.parseindex(data, inline)[0] index = parse_index_v1(data, inline)[0]
rev = getattr(index, 'rev', None) rev = getattr(index, 'rev', None)
if rev is None: if rev is None:
nodemap = getattr( nodemap = getattr(parse_index_v1(data, inline)[0], 'nodemap', None)
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
rev = nodemap.__getitem__ rev = nodemap.__getitem__
try: try:
rev(node) rev(node)
except error.RevlogError: except error.RevlogError:
pass pass
def resolvenodes(nodes, count=1): def resolvenodes(nodes, count=1):
index = revlogio.parseindex(data, inline)[0] index = parse_index_v1(data, inline)[0]
rev = getattr(index, 'rev', None) rev = getattr(index, 'rev', None)
if rev is None: if rev is None:
nodemap = getattr( nodemap = getattr(parse_index_v1(data, inline)[0], 'nodemap', None)
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
rev = nodemap.__getitem__ rev = nodemap.__getitem__
for i in range(count): for i in range(count):
for node in nodes: for node in nodes:
try: try:

mercurial/revlog.py

wdirrev, wdirrev,
) )
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .revlogutils.constants import ( from .revlogutils.constants import (
FLAG_GENERALDELTA, FLAG_GENERALDELTA,
FLAG_INLINE_DATA, FLAG_INLINE_DATA,
INDEX_ENTRY_V0, INDEX_ENTRY_V0,
INDEX_ENTRY_V1,
INDEX_ENTRY_V2,
INDEX_HEADER, INDEX_HEADER,
REVLOGV0, REVLOGV0,
REVLOGV1, REVLOGV1,
REVLOGV1_FLAGS, REVLOGV1_FLAGS,
REVLOGV2, REVLOGV2,
REVLOGV2_FLAGS, REVLOGV2_FLAGS,
REVLOG_DEFAULT_FLAGS, REVLOG_DEFAULT_FLAGS,
REVLOG_DEFAULT_FORMAT, REVLOG_DEFAULT_FORMAT,
entry[4], entry[4],
self[entry[5]][7], self[entry[5]][7],
self[entry[6]][7], self[entry[6]][7],
entry[7], entry[7],
) )
return INDEX_ENTRY_V0.pack(*e2) return INDEX_ENTRY_V0.pack(*e2)
class revlogoldio(object): def parse_index_v0(data, inline):
def parseindex(self, data, inline):
s = INDEX_ENTRY_V0.size s = INDEX_ENTRY_V0.size
index = [] index = []
nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev}) nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
n = off = 0 n = off = 0
l = len(data) l = len(data)
while off + s <= l: while off + s <= l:
cur = data[off : off + s] cur = data[off : off + s]
off += s off += s
e = INDEX_ENTRY_V0.unpack(cur) e = INDEX_ENTRY_V0.unpack(cur)
# transform to revlogv1 format # transform to revlogv1 format
e2 = ( e2 = (
offset_type(e[0], 0), offset_type(e[0], 0),
e[1], e[1],
-1, -1,
e[2], e[2],
e[3], e[3],
nodemap.get(e[4], nullrev), nodemap.get(e[4], nullrev),
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, None return index, None
# corresponds to uncompressed length of indexformatng (2 gigs, 4-byte def parse_index_v1(data, inline):
# signed integer)
_maxentrysize = 0x7FFFFFFF
class revlogio(object):
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, cache return index, cache
class revlogv2io(object): def parse_index_v2(data, inline):
def parseindex(self, data, inline): # call the C implementation to parse the index data
index, cache = parsers.parse_index2(data, inline, revlogv2=True) index, cache = parsers.parse_index2(data, inline, revlogv2=True)
return index, cache return index, cache
NodemapRevlogIO = None
if util.safehasattr(parsers, 'parse_index_devel_nodemap'): if util.safehasattr(parsers, 'parse_index_devel_nodemap'):
class NodemapRevlogIO(revlogio): def parse_index_v1_nodemap(data, inline):
"""A debug oriented IO class that return a PersistentNodeMapIndexObject
The PersistentNodeMapIndexObject object is meant to test the persistent nodemap feature.
"""
def parseindex(self, data, inline):
index, cache = parsers.parse_index_devel_nodemap(data, inline) index, cache = parsers.parse_index_devel_nodemap(data, inline)
return index, cache return index, cache
class rustrevlogio(revlogio): else:
def parseindex(self, data, inline): parse_index_v1_nodemap = None
index, cache = super(rustrevlogio, self).parseindex(data, inline)
def parse_index_v1_mixed(data, inline):
index, cache = parse_index_v1(data, inline)
return rustrevlog.MixedIndex(index), cache return rustrevlog.MixedIndex(index), cache
# corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
# signed integer)
_maxentrysize = 0x7FFFFFFF
class revlog(object): class revlog(object):
""" """
the underlying revision storage object the underlying revision storage object
A revlog consists of two parts, an index and the revision data. A revlog consists of two parts, an index and the revision data.
The index is a file with a fixed record size containing The index is a file with a fixed record size containing
information on each revision, including its nodeid (hash), the information on each revision, including its nodeid (hash), the
if not self._generaldelta: if not self._generaldelta:
self._sparserevlog = False self._sparserevlog = False
self._storedeltachains = True self._storedeltachains = True
devel_nodemap = ( devel_nodemap = (
self.nodemap_file self.nodemap_file
and opts.get(b'devel-force-nodemap', False) and opts.get(b'devel-force-nodemap', False)
and NodemapRevlogIO is not None and parse_index_v1_nodemap is not None
) )
use_rust_index = False use_rust_index = False
if rustrevlog is not None: if rustrevlog is not None:
if self.nodemap_file is not None: if self.nodemap_file is not None:
use_rust_index = True use_rust_index = True
else: else:
use_rust_index = self.opener.options.get(b'rust.index') use_rust_index = self.opener.options.get(b'rust.index')
self._io = revlogio() self._parse_index = parse_index_v1
if self.version == REVLOGV0: if self.version == REVLOGV0:
self._io = revlogoldio() self._parse_index = parse_index_v0
elif fmt == REVLOGV2: elif fmt == REVLOGV2:
self._io = revlogv2io() self._parse_index = parse_index_v2
elif devel_nodemap: elif devel_nodemap:
self._io = NodemapRevlogIO() self._parse_index = parse_index_v1_nodemap
elif use_rust_index: elif use_rust_index:
self._io = rustrevlogio() self._parse_index = parse_index_v1_mixed
try: try:
d = self._io.parseindex(indexdata, self._inline) d = self._parse_index(indexdata, self._inline)
index, _chunkcache = d index, _chunkcache = d
use_nodemap = ( use_nodemap = (
not self._inline not self._inline
and self.nodemap_file is not None and self.nodemap_file is not None
and util.safehasattr(index, 'update_nodemap_data') and util.safehasattr(index, 'update_nodemap_data')
) )
if use_nodemap: if use_nodemap:
nodemap_data = nodemaputil.persisted_data(self) nodemap_data = nodemaputil.persisted_data(self)
for r in self: for r in self:
dfh.write(self._getsegmentforrevs(r, r, df=ifh)[1]) dfh.write(self._getsegmentforrevs(r, r, df=ifh)[1])
if troffset <= self.start(r): if troffset <= self.start(r):
trindex = r trindex = r
with self._indexfp(b'w') as fp: with self._indexfp(b'w') as fp:
self.version &= ~FLAG_INLINE_DATA self.version &= ~FLAG_INLINE_DATA
self._inline = False self._inline = False
io = self._io
for i in self: for i in self:
e = self.index.entry_binary(i, self.version) e = self.index.entry_binary(i, self.version)
fp.write(e) fp.write(e)
# the temp file replace the real index when we exit the context # the temp file replace the real index when we exit the context
# manager # manager
tr.replace(self.indexfile, trindex * self.index.entry_size) tr.replace(self.indexfile, trindex * self.index.entry_size)
newindexfile = self.indexfile + b'.tmpcensored' newindexfile = self.indexfile + b'.tmpcensored'
newdatafile = self.datafile + b'.tmpcensored' newdatafile = self.datafile + b'.tmpcensored'
# This is a bit dangerous. We could easily have a mismatch of state. # This is a bit dangerous. We could easily have a mismatch of state.
newrl = revlog(self.opener, newindexfile, newdatafile, censorable=True) newrl = revlog(self.opener, newindexfile, newdatafile, censorable=True)
newrl.version = self.version newrl.version = self.version
newrl._generaldelta = self._generaldelta newrl._generaldelta = self._generaldelta
newrl._io = self._io newrl._parse_index = self._parse_index
for rev in self.revs(): for rev in self.revs():
node = self.node(rev) node = self.node(rev)
p1, p2 = self.parents(node) p1, p2 = self.parents(node)
if rev == censorrev: if rev == censorrev:
newrl.addrawrevision( newrl.addrawrevision(
tombstone, tombstone,