( )⚙ D10509 revlog: remove the revlogio class

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 27270

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,