This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7312

revlog: introduce an explicit NodeMap class for pure code
ClosedPublic

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

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGa7c0c5b5a50f: revlog: introduce an explicit NodeMap class for pure code
rHG2385a4e0010e: revlog: introduce an explicit NodeMap class for pure code
Summary

This class make the "pure" nodemap raise the same exception than the C-extension
one.

This is a step toward unifying nodemap and index, the class is not meant to
survive on the long run.

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

There is a new isinstance call, it will be cleaned up in coming changesets.

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.Nov 8 2019, 4:28 AM
indygreg accepted this revision.Nov 8 2019, 2:27 PM

I hope the end state of this series establishes a formal interface for the index API. There is so much low-hanging fruit to be realized there. And we desperately need a format interface to abstract changelog storage.

This revision is now accepted and ready to land.Nov 8 2019, 2:27 PM
yuja added a subscriber: yuja.Nov 10 2019, 4:45 AM

+class NodeMap(dict):
+ def missing(self, x):
+ raise error.RevlogError('unknown node: %s' % x)

Missed b'' and node.hex|short()?

Revision Contents
Changeset List

PathPackages
Mmercurial/revlog.py (50 lines)
Mmercurial/revlogutils/__init__.py (14 lines)

Diff 17825

mercurial/revlog.py

from .thirdparty import attr from .thirdparty import attr
from . import ( from . import (
ancestor, ancestor,
dagop, dagop,
error, error,
mdiff, mdiff,
policy, policy,
pycompat, pycompat,
revlogutils,
templatefilters, templatefilters,
util, util,
) )
from .interfaces import ( from .interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from .revlogutils import ( from .revlogutils import (
class revlogoldio(object): class revlogoldio(object):
def __init__(self): def __init__(self):
self.size = indexformatv0.size self.size = indexformatv0.size
def parseindex(self, data, inline): def parseindex(self, data, inline):
s = self.size s = self.size
index = [] index = []
nodemap = {nullid: nullrev} nodemap = revlogutils.NodeMap({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 = indexformatv0_unpack(cur) e = indexformatv0_unpack(cur)
# transform to revlogv1 format # transform to revlogv1 format
e2 = ( e2 = (
# How much data to read and cache into the raw revlog data cache. # How much data to read and cache into the raw revlog data cache.
self._chunkcachesize = 65536 self._chunkcachesize = 65536
self._maxchainlen = None self._maxchainlen = None
self._deltabothparents = True self._deltabothparents = True
self.index = [] self.index = []
# Mapping of partial identifiers to full nodes. # Mapping of partial identifiers to full nodes.
self._pcache = {} self._pcache = {}
# Mapping of revision integer to full node. # Mapping of revision integer to full node.
self._nodecache = {nullid: nullrev} self._nodecache = revlogutils.NodeMap({nullid: nullrev})
self._nodepos = None self._nodepos = None
self._compengine = b'zlib' self._compengine = b'zlib'
self._compengineopts = {} self._compengineopts = {}
self._maxdeltachainspan = -1 self._maxdeltachainspan = -1
self._withsparseread = False self._withsparseread = False
self._sparserevlog = False self._sparserevlog = False
self._srdensitythreshold = 0.50 self._srdensitythreshold = 0.50
self._srmingapsize = 262144 self._srmingapsize = 262144
self._pcache = {} self._pcache = {}
try: try:
# If we are using the native C version, you are in a fun case # If we are using the native C version, you are in a fun case
# where self.index, self.nodemap and self._nodecaches is the same # where self.index, self.nodemap and self._nodecaches is the same
# object. # object.
self._nodecache.clearcaches() self._nodecache.clearcaches()
except AttributeError: except AttributeError:
self._nodecache = {nullid: nullrev} self._nodecache = revlogutils.NodeMap({nullid: nullrev})
self._nodepos = None self._nodepos = None
def rev(self, node): def rev(self, node):
try: try:
return self._nodecache[node] return self._nodecache[node]
except TypeError: except TypeError:
raise raise
except error.RevlogError: except error.RevlogError:
if not isinstance(self._nodecache, revlogutils.NodeMap):
# parsers.c radix tree lookup failed # parsers.c radix tree lookup failed
if node == wdirid or node in wdirfilenodeids: if node == wdirid or node in wdirfilenodeids:
raise error.WdirUnsupported raise error.WdirUnsupported
raise error.LookupError(node, self.indexfile, _(b'no node')) raise error.LookupError(node, self.indexfile, _(b'no node'))
except KeyError: else:
# pure python cache lookup failed # pure python cache lookup failed
n = self._nodecache n = self._nodecache
i = self.index i = self.index
p = self._nodepos p = self._nodepos
if p is None: if p is None:
p = len(i) - 1 p = len(i) - 1
else: else:
assert p < len(i) assert p < len(i)
for r in pycompat.xrange(p, -1, -1): for r in pycompat.xrange(p, -1, -1):
v = i[r][7] v = i[r][7]
n[v] = r n[v] = r
if v == node: if v == node:
self._nodepos = r - 1 self._nodepos = r - 1
return r return r
if node == wdirid or node in wdirfilenodeids: if node == wdirid or node in wdirfilenodeids:
raise error.WdirUnsupported raise error.WdirUnsupported
raise error.LookupError(node, self.indexfile, _(b'no node')) raise error.LookupError(node, self.indexfile, _(b'no node'))
# Accessors for index entries. # Accessors for index entries.
# First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes
# are flags. # are flags.
def start(self, rev): def start(self, rev):
return int(self.index[rev][0] >> 16) return int(self.index[rev][0] >> 16)

mercurial/revlogutils/__init__.py

# mercurial.revlogutils -- basic utilities for revlog
#
# Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
from .. import error
class NodeMap(dict):
def __missing__(self, x):
raise error.RevlogError('unknown node: %s' % x)