This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9882

revlog: change addrevision to return the new revision, not node
ClosedPublic

Authored by joerg.sonnenberger on Jan 26 2021, 9:10 PM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf7b61ad3c64a: revlog: change addrevision to return the new revision, not node
rHGb38ac14306ae: revlog: change addrevision to return the new revision, not node

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

Alphare added a subscriber: Alphare.Jan 30 2021, 5:27 AM

Does this have any influence on performance?

joerg.sonnenberger added a comment.Jan 30 2021, 7:36 AM

I didn't measure it, but I don't expect it to make a difference. rev->node is the cheap mapping in all cases, it is the reverse that can be expensive.

Alphare accepted this revision.Feb 8 2021, 9:45 AM
joerg.sonnenberger added a commit: rHGb38ac14306ae: revlog: change addrevision to return the new revision, not node.Feb 11 2021, 11:38 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGb38ac14306ae: revlog: change addrevision to return the new revision, not node (authored by joerg.sonnenberger). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25421

hgext/sqlitestore.py

# End of ifiledata interface. # End of ifiledata interface.
# Start of ifilemutation interface. # Start of ifilemutation interface.
def add(self, filedata, meta, transaction, linkrev, p1, p2): def add(self, filedata, meta, transaction, linkrev, p1, p2):
if meta or filedata.startswith(b'\x01\n'): if meta or filedata.startswith(b'\x01\n'):
filedata = storageutil.packmeta(meta, filedata) filedata = storageutil.packmeta(meta, filedata)
return self.addrevision(filedata, transaction, linkrev, p1, p2) rev = self.addrevision(filedata, transaction, linkrev, p1, p2)
return self.node(rev)
def addrevision( def addrevision(
self, self,
revisiondata, revisiondata,
transaction, transaction,
linkrev, linkrev,
p1, p1,
p2, p2,
node=None, node=None,
flags=0, flags=0,
cachedelta=None, cachedelta=None,
): ):
if flags: if flags:
raise SQLiteStoreError(_(b'flags not supported on revisions')) raise SQLiteStoreError(_(b'flags not supported on revisions'))
validatehash = node is not None validatehash = node is not None
node = node or storageutil.hashrevisionsha1(revisiondata, p1, p2) node = node or storageutil.hashrevisionsha1(revisiondata, p1, p2)
if validatehash: if validatehash:
self._checkhash(revisiondata, node, p1, p2) self._checkhash(revisiondata, node, p1, p2)
if node in self._nodetorev: rev = self._nodetorev.get(node)
return node if rev is not None:
return rev
node = self._addrawrevision( rev = self._addrawrevision(
node, revisiondata, transaction, linkrev, p1, p2 node, revisiondata, transaction, linkrev, p1, p2
) )
self._revisioncache[node] = revisiondata self._revisioncache[node] = revisiondata
return node return rev
def addgroup( def addgroup(
self, self,
deltas, deltas,
linkmapper, linkmapper,
transaction, transaction,
addrevisioncb=None, addrevisioncb=None,
duplicaterevisioncb=None, duplicaterevisioncb=None,
linkrev=linkrev, linkrev=linkrev,
flags=flags, flags=flags,
) )
self._nodetorev[node] = rev self._nodetorev[node] = rev
self._revtonode[rev] = node self._revtonode[rev] = node
self._revisions[node] = entry self._revisions[node] = entry
return node return rev
class sqliterepository(localrepo.localrepository): class sqliterepository(localrepo.localrepository):
def cancopy(self): def cancopy(self):
return False return False
def transaction(self, *args, **kwargs): def transaction(self, *args, **kwargs):
current = self.currenttransaction() current = self.currenttransaction()

mercurial/changelog.py

flags |= flagutil.REVIDX_HASCOPIESINFO flags |= flagutil.REVIDX_HASCOPIESINFO
sidedata = metadata.encode_files_sidedata(files) sidedata = metadata.encode_files_sidedata(files)
if extra: if extra:
extra = encodeextra(extra) extra = encodeextra(extra)
parseddate = b"%s %s" % (parseddate, extra) parseddate = b"%s %s" % (parseddate, extra)
l = [hex(manifest), user, parseddate] + sortedfiles + [b"", desc] l = [hex(manifest), user, parseddate] + sortedfiles + [b"", desc]
text = b"\n".join(l) text = b"\n".join(l)
return self.addrevision( rev = self.addrevision(
text, transaction, len(self), p1, p2, sidedata=sidedata, flags=flags text, transaction, len(self), p1, p2, sidedata=sidedata, flags=flags
) )
return self.node(rev)
def branchinfo(self, rev): def branchinfo(self, rev):
"""return the branch name and open/close state of a revision """return the branch name and open/close state of a revision
This function exists because creating a changectx object This function exists because creating a changectx object
just to access this is costly.""" just to access this is costly."""
return self.changelogrevision(rev).branchinfo return self.changelogrevision(rev).branchinfo
def _nodeduplicatecallback(self, transaction, node): def _nodeduplicatecallback(self, transaction, node):
# keep track of revisions that got "re-added", eg: unbunde of know rev. # keep track of revisions that got "re-added", eg: unbunde of know rev.
# #
# We track them in a list to preserve their order from the source bundle # We track them in a list to preserve their order from the source bundle
duplicates = transaction.changes.setdefault(b'revduplicates', []) duplicates = transaction.changes.setdefault(b'revduplicates', [])
duplicates.append(self.rev(node)) duplicates.append(self.rev(node))

mercurial/filelog.py

return self._revlog.files() return self._revlog.files()
def read(self, node): def read(self, node):
return storageutil.filtermetadata(self.revision(node)) return storageutil.filtermetadata(self.revision(node))
def add(self, text, meta, transaction, link, p1=None, p2=None): def add(self, text, meta, transaction, link, p1=None, p2=None):
if meta or text.startswith(b'\1\n'): if meta or text.startswith(b'\1\n'):
text = storageutil.packmeta(meta, text) text = storageutil.packmeta(meta, text)
return self.addrevision(text, transaction, link, p1, p2) rev = self.addrevision(text, transaction, link, p1, p2)
return self.node(rev)
def renamed(self, node): def renamed(self, node):
return storageutil.filerevisioncopied(self, node) return storageutil.filerevisioncopied(self, node)
def size(self, rev): def size(self, rev):
"""return the size of a given revision""" """return the size of a given revision"""
# for revisions with renames, we have to go the slow way # for revisions with renames, we have to go the slow way

mercurial/interfaces/repository.py

transaction, transaction,
linkrev, linkrev,
p1, p1,
p2, p2,
node=None, node=None,
flags=0, flags=0,
cachedelta=None, cachedelta=None,
): ):
"""Add a new revision to the store. """Add a new revision to the store and return its number.
This is similar to ``add()`` except it operates at a lower level. This is similar to ``add()`` except it operates at a lower level.
The data passed in already contains a metadata header, if any. The data passed in already contains a metadata header, if any.
``node`` and ``flags`` can be used to define the expected node and ``node`` and ``flags`` can be used to define the expected node and
the flags to use with storage. ``flags`` is a bitwise value composed the flags to use with storage. ``flags`` is a bitwise value composed
of the various ``REVISION_FLAG_*`` constants. of the various ``REVISION_FLAG_*`` constants.

mercurial/manifest.py

work = heapq.merge( work = heapq.merge(
[(x, False) for x in sorted(added)], [(x, False) for x in sorted(added)],
[(x, True) for x in sorted(removed)], [(x, True) for x in sorted(removed)],
) )
arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work) arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
cachedelta = self._revlog.rev(p1), deltatext cachedelta = self._revlog.rev(p1), deltatext
text = util.buffer(arraytext) text = util.buffer(arraytext)
n = self._revlog.addrevision( rev = self._revlog.addrevision(
text, transaction, link, p1, p2, cachedelta text, transaction, link, p1, p2, cachedelta
) )
n = self._revlog.node(rev)
except FastdeltaUnavailable: except FastdeltaUnavailable:
# The first parent manifest isn't already loaded or the # The first parent manifest isn't already loaded or the
# manifest implementation doesn't support fastdelta, so # manifest implementation doesn't support fastdelta, so
# we'll just encode a fulltext of the manifest and pass # we'll just encode a fulltext of the manifest and pass
# that through to the revlog layer, and let it handle the # that through to the revlog layer, and let it handle the
# delta process. # delta process.
if self._treeondisk: if self._treeondisk:
assert readtree, b"readtree must be set for treemanifest writes" assert readtree, b"readtree must be set for treemanifest writes"
assert match, b"match must be specified for treemanifest writes" assert match, b"match must be specified for treemanifest writes"
m1 = readtree(self.tree, p1) m1 = readtree(self.tree, p1)
m2 = readtree(self.tree, p2) m2 = readtree(self.tree, p2)
n = self._addtree( n = self._addtree(
m, transaction, link, m1, m2, readtree, match=match m, transaction, link, m1, m2, readtree, match=match
) )
arraytext = None arraytext = None
else: else:
text = m.text() text = m.text()
n = self._revlog.addrevision(text, transaction, link, p1, p2) rev = self._revlog.addrevision(text, transaction, link, p1, p2)
n = self._revlog.node(rev)
arraytext = bytearray(text) arraytext = bytearray(text)
if arraytext is not None: if arraytext is not None:
self.fulltextcache[n] = arraytext self.fulltextcache[n] = arraytext
return n return n
def _addtree(self, m, transaction, link, m1, m2, readtree, match): def _addtree(self, m, transaction, link, m1, m2, readtree, match):
if self.tree != b'': if self.tree != b'':
# Double-check whether contents are unchanged to one parent # Double-check whether contents are unchanged to one parent
if text == m1.dirtext(): if text == m1.dirtext():
n = m1.node() n = m1.node()
elif text == m2.dirtext(): elif text == m2.dirtext():
n = m2.node() n = m2.node()
if not n: if not n:
n = self._revlog.addrevision( rev = self._revlog.addrevision(
text, transaction, link, m1.node(), m2.node() text, transaction, link, m1.node(), m2.node()
) )
n = self._revlog.node(rev)
# Save nodeid so parent manifest can calculate its nodeid # Save nodeid so parent manifest can calculate its nodeid
m.setnode(n) m.setnode(n)
return n return n
def __len__(self): def __len__(self):
return len(self._revlog) return len(self._revlog)

mercurial/revlog.py

raise error.RevlogError( raise error.RevlogError(
_( _(
b"%s: size of %d bytes exceeds maximum revlog storage of 2GiB" b"%s: size of %d bytes exceeds maximum revlog storage of 2GiB"
) )
% (self.indexfile, len(rawtext)) % (self.indexfile, len(rawtext))
) )
node = node or self.hash(rawtext, p1, p2) node = node or self.hash(rawtext, p1, p2)
if self.index.has_node(node): rev = self.index.get_rev(node)
return node if rev is not None:
return rev
if validatehash: if validatehash:
self.checkhash(rawtext, node, p1=p1, p2=p2) self.checkhash(rawtext, node, p1=p1, p2=p2)
rev = self.addrawrevision( return self.addrawrevision(
rawtext, rawtext,
transaction, transaction,
link, link,
p1, p1,
p2, p2,
node, node,
flags, flags,
cachedelta=cachedelta, cachedelta=cachedelta,
deltacomputer=deltacomputer, deltacomputer=deltacomputer,
) )
return node
def addrawrevision( def addrawrevision(
self, self,
rawtext, rawtext,
transaction, transaction,
link, link,
p1, p1,
p2, p2,