This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4224

changegroup: move node sorting into deltagroup()
ClosedPublic

Authored by indygreg on Aug 9 2018, 7:12 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG2646b8d66b7b: changegroup: move node sorting into deltagroup()
Summary

The 3 callers of deltagroup() all sort nodes and convert to
integer revs immediately before calling deltagroup().

Stepping back a bit, aside from the constraints on node ordering
that always apply (namely that a node must follow its ancestor),
it makes sense for sorting to be an implementation detail of the
store. Moving the sorting into deltagroup() will open the door
for moving sorting into a storage API.

The test for the changelog in deltagroup() to impact the sorting
method is a bit hacky. I suspect this will be resolved once
we establish a formal interface for delta group generation
and port changelog to it.

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

indygreg created this revision.Aug 9 2018, 7:12 PM
Closed by commit rHG2646b8d66b7b: changegroup: move node sorting into deltagroup() (authored by indygreg). · Explain WhyAug 22 2018, 12:36 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (48 lines)

Diff 10509

mercurial/changegroup.py

node=node, node=node,
p1node=p1node, p1node=p1node,
p2node=p2node, p2node=p2node,
linknode=linknode, linknode=linknode,
basenode=nullid, basenode=nullid,
ellipsis=True, ellipsis=True,
) )
def deltagroup(repo, revs, store, ischangelog, lookup, forcedeltaparentprev, def deltagroup(repo, store, nodes, ischangelog, lookup, forcedeltaparentprev,
allowreorder,
units=None, units=None,
ellipses=False, clrevtolocalrev=None, fullclnodes=None, ellipses=False, clrevtolocalrev=None, fullclnodes=None,
precomputedellipsis=None): precomputedellipsis=None):
"""Calculate deltas for a set of revisions. """Calculate deltas for a set of revisions.
Is a generator of ``revisiondelta`` instances. Is a generator of ``revisiondelta`` instances.
If units is not None, progress detail will be generated, units specifies If units is not None, progress detail will be generated, units specifies
the type of revlog that is touched (changelog, manifest, etc.). the type of revlog that is touched (changelog, manifest, etc.).
""" """
if not revs: if not nodes:
return return
# We perform two passes over the revisions whose data we will emit. # We perform two passes over the revisions whose data we will emit.
# #
# In the first pass, we obtain information about the deltas that will # In the first pass, we obtain information about the deltas that will
# be generated. This involves computing linknodes and adjusting the # be generated. This involves computing linknodes and adjusting the
# request to take shallow fetching into account. The end result of # request to take shallow fetching into account. The end result of
# this pass is a list of "request" objects stating which deltas # this pass is a list of "request" objects stating which deltas
# to obtain. # to obtain.
# #
# The second pass is simply resolving the requested deltas. # The second pass is simply resolving the requested deltas.
cl = repo.changelog cl = repo.changelog
if ischangelog:
# Changelog doesn't benefit from reordering revisions. So send
# out revisions in store order.
# TODO the API would be cleaner if this were controlled by the
# store producing the deltas.
revs = sorted(cl.rev(n) for n in nodes)
elif ellipses:
revs = _sortnodesellipsis(store, nodes, cl, lookup)
else:
revs = _sortnodesnormal(store, nodes, allowreorder)
# In the first pass, collect info about the deltas we'll be # In the first pass, collect info about the deltas we'll be
# generating. # generating.
requests = [] requests = []
# Add the parent of the first rev. # Add the parent of the first rev.
revs.insert(0, store.parentrevs(revs[0])[0]) revs.insert(0, store.parentrevs(revs[0])[0])
for i in pycompat.xrange(len(revs) - 1): for i in pycompat.xrange(len(revs) - 1):
# record the first changeset introducing this manifest version # record the first changeset introducing this manifest version
mfs.setdefault(n, x) mfs.setdefault(n, x)
# Record a complete list of potentially-changed files in # Record a complete list of potentially-changed files in
# this manifest. # this manifest.
changedfiles.update(c[3]) changedfiles.update(c[3])
return x return x
# Changelog doesn't benefit from reordering revisions. So send out
# revisions in store order.
revs = sorted(cl.rev(n) for n in nodes)
state = { state = {
'clrevorder': clrevorder, 'clrevorder': clrevorder,
'mfs': mfs, 'mfs': mfs,
'changedfiles': changedfiles, 'changedfiles': changedfiles,
'clrevtomanifestrev': clrevtomanifestrev, 'clrevtomanifestrev': clrevtomanifestrev,
} }
gen = deltagroup( gen = deltagroup(
self._repo, revs, cl, True, lookupcl, self._repo, cl, nodes, True, lookupcl,
self._forcedeltaparentprev, self._forcedeltaparentprev,
# Reorder settings are currently ignored for changelog.
True,
ellipses=self._ellipses, ellipses=self._ellipses,
units=_('changesets'), units=_('changesets'),
clrevtolocalrev={}, clrevtolocalrev={},
fullclnodes=self._fullclnodes, fullclnodes=self._fullclnodes,
precomputedellipsis=self._precomputedellipsis) precomputedellipsis=self._precomputedellipsis)
return state, gen return state, gen
def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs, def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs,
fnodes, source, clrevtolocalrev): fnodes, source, clrevtolocalrev):
"""Returns an iterator of changegroup chunks containing manifests. """Returns an iterator of changegroup chunks containing manifests.
`source` is unused here, but is used by extensions like remotefilelog to `source` is unused here, but is used by extensions like remotefilelog to
change what is sent based in pulls vs pushes, etc. change what is sent based in pulls vs pushes, etc.
""" """
repo = self._repo repo = self._repo
cl = repo.changelog
mfl = repo.manifestlog mfl = repo.manifestlog
dirlog = mfl._revlog.dirlog dirlog = mfl._revlog.dirlog
tmfnodes = {'': mfs} tmfnodes = {'': mfs}
# Callback for the manifest, used to collect linkrevs for filelog # Callback for the manifest, used to collect linkrevs for filelog
# revisions. # revisions.
# Returns the linkrev node (collected in lookupcl). # Returns the linkrev node (collected in lookupcl).
def makelookupmflinknode(dir, nodes): def makelookupmflinknode(dir, nodes):
prunednodes = [n for n in nodes prunednodes = [n for n in nodes
if flr(frev(n)) not in commonrevs] if flr(frev(n)) not in commonrevs]
if dir and not prunednodes: if dir and not prunednodes:
continue continue
lookupfn = makelookupmflinknode(dir, nodes) lookupfn = makelookupmflinknode(dir, nodes)
if self._ellipses:
revs = _sortnodesellipsis(store, prunednodes, cl,
lookupfn)
else:
revs = _sortnodesnormal(store, prunednodes,
self._reorder)
deltas = deltagroup( deltas = deltagroup(
self._repo, revs, store, False, lookupfn, self._repo, store, prunednodes, False, lookupfn,
self._forcedeltaparentprev, self._forcedeltaparentprev, self._reorder,
ellipses=self._ellipses, ellipses=self._ellipses,
units=_('manifests'), units=_('manifests'),
clrevtolocalrev=clrevtolocalrev, clrevtolocalrev=clrevtolocalrev,
fullclnodes=self._fullclnodes, fullclnodes=self._fullclnodes,
precomputedellipsis=self._precomputedellipsis) precomputedellipsis=self._precomputedellipsis)
yield dir, deltas yield dir, deltas
links[fnode] = min(links[fnode], lr, key=clrev) links[fnode] = min(links[fnode], lr, key=clrev)
elif fnode: elif fnode:
links[fnode] = lr links[fnode] = lr
return links return links
else: else:
linknodes = normallinknodes linknodes = normallinknodes
repo = self._repo repo = self._repo
cl = repo.changelog
progress = repo.ui.makeprogress(_('bundling'), unit=_('files'), progress = repo.ui.makeprogress(_('bundling'), unit=_('files'),
total=len(changedfiles)) total=len(changedfiles))
for i, fname in enumerate(sorted(changedfiles)): for i, fname in enumerate(sorted(changedfiles)):
filerevlog = repo.file(fname) filerevlog = repo.file(fname)
if not filerevlog: if not filerevlog:
raise error.Abort(_("empty or missing file data for %s") % raise error.Abort(_("empty or missing file data for %s") %
fname) fname)
clrevtolocalrev.clear() clrevtolocalrev.clear()
linkrevnodes = linknodes(filerevlog, fname) linkrevnodes = linknodes(filerevlog, fname)
# Lookup for filenodes, we collected the linkrev nodes above in the # Lookup for filenodes, we collected the linkrev nodes above in the
# fastpath case and with lookupmf in the slowpath case. # fastpath case and with lookupmf in the slowpath case.
def lookupfilelog(x): def lookupfilelog(x):
return linkrevnodes[x] return linkrevnodes[x]
frev, flr = filerevlog.rev, filerevlog.linkrev frev, flr = filerevlog.rev, filerevlog.linkrev
filenodes = [n for n in linkrevnodes filenodes = [n for n in linkrevnodes
if flr(frev(n)) not in commonrevs] if flr(frev(n)) not in commonrevs]
if not filenodes: if not filenodes:
continue continue
if self._ellipses:
revs = _sortnodesellipsis(filerevlog, filenodes,
cl, lookupfilelog)
else:
revs = _sortnodesnormal(filerevlog, filenodes,
self._reorder)
progress.update(i + 1, item=fname) progress.update(i + 1, item=fname)
deltas = deltagroup( deltas = deltagroup(
self._repo, revs, filerevlog, False, lookupfilelog, self._repo, filerevlog, filenodes, False, lookupfilelog,
self._forcedeltaparentprev, self._forcedeltaparentprev, self._reorder,
ellipses=self._ellipses, ellipses=self._ellipses,
clrevtolocalrev=clrevtolocalrev, clrevtolocalrev=clrevtolocalrev,
fullclnodes=self._fullclnodes, fullclnodes=self._fullclnodes,
precomputedellipsis=self._precomputedellipsis) precomputedellipsis=self._precomputedellipsis)
yield fname, deltas yield fname, deltas
progress.complete() progress.complete()