This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4215

changegroup: introduce requests to define delta generation
ClosedPublic

Authored by indygreg on Aug 9 2018, 4:52 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGe793e11e1462: changegroup: introduce requests to define delta generation
Summary

Currently, we iterate through each revision we will be producing
a delta for then call into 1 of 2 functions for generating that
delta. Deltas are emitted as we iterate.

A problem with this model is that revision generation is tightly
coupled to the changegroup code. And the storage layer needs to
expose APIs like deltaparent() so changegroup delta generation
can produce a delta with that knowledge.

Another problem is that in this model, deltas can only be produced
sequentially after the previous delta was produced and emitted.
Some storage backends might be capable of producing deltas in
parallel (e.g. if the changegroup deltas are cached somewhere).

This commit aims to solve these problems by turning delta generation
into a 2 phase implementation where the first phase determines
info about all the deltas that need to be generated and the 2nd
phase resolves those deltas.

We introduce a "revisiondeltarequest" object that holds data about
a to-be-generated delta. We perform a full pass over all revisions
whose delta is to be generated and generate a "revisiondeltarequest"
for each. Then we iterate over the "revisiondeltarequest" instances
and derive a "revisiondelta" for each.

This patch was quite large. In order to avoid even more churn, aspects
of the implementation are less than ideal. e.g. we're recording
revision numbers instead of nodes in a few places and we don't
yet have a formal API for resolving an iterable of revisiondeltarequest
instances. Things will be improved in subsequent commits.

Unfortunately, this commit reduces performance substantially. For
hg perfchangegroupchangelog on my hg repo:

! wall 1.512607 comb 1.510000 user 1.490000 sys 0.020000 (best of 7)
! wall 2.150863 comb 2.150000 user 2.150000 sys 0.000000 (best of 5)

And for hg bundle -t none-v2 -a for the mozilla-unified repo:

178.32user 4.22system 3:02.59elapsed
190.97user 4.17system 3:15.19elapsed

Some of this was attributed to changelog slowdown. `hg
perfchangegroupchangelog` on mozilla-unified:

! wall 21.688715 comb 21.690000 user 21.570000 sys 0.120000 (best of 3)
! wall 25.683659 comb 25.680000 user 25.540000 sys 0.140000 (best of 3)

Profiling seems to reveal that the changelog slowdown is due to reading
changelog revisions multiple times. First in the linknode callback
to resolve the set of files changed. Second in the delta generation.
Before, we likely had hit the last revision cache in the revlog when
doing delta generation since we performed that immediately after
performing the linknode callback.

I'm not exactly sure where the other ~8s are being spent. It might be
from overhead of constructing a few million revisiondeltarequest
objects. I'm OK with the regression for now because it is in service
of a larger cause (storage abstraction). I'll try to profile later
and claw back the performance.

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.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (155 lines)

Diff 10239

mercurial/changegroup.py

if self._h: if self._h:
d, self._h = self._h[:n], self._h[n:] d, self._h = self._h[:n], self._h[n:]
if len(d) < n: if len(d) < n:
d += readexactly(self._fh, n - len(d)) d += readexactly(self._fh, n - len(d))
return d return d
return readexactly(self._fh, n) return readexactly(self._fh, n)
@attr.s(slots=True, frozen=True) @attr.s(slots=True, frozen=True)
class revisiondeltarequest(object):
"""Describes a request to construct a revision delta.
Instances are converted into ``revisiondelta`` later.
"""
# Revision whose delta will be generated.
node = attr.ib()
# Linknode value.
linknode = attr.ib()
# Parent revisions to record in ``revisiondelta`` instance.
p1node = attr.ib()
p2node = attr.ib()
# Base revision that delta should be generated against. If nullrev,
# the full revision data should be populated. If None, the delta
# may be generated against any base revision that is an ancestor of
# this revision. If any other numeric value, the delta should be
# produced against that revision.
baserev = attr.ib()
# Whether this should be marked as an ellipsis revision.
ellipsis = attr.ib(default=False)
@attr.s(slots=True, frozen=True)
class revisiondelta(object): class revisiondelta(object):
"""Describes a delta entry in a changegroup. """Describes a delta entry in a changegroup.
Captured data is sufficient to serialize the delta into multiple Captured data is sufficient to serialize the delta into multiple
formats. formats.
``revision`` and ``delta`` are mutually exclusive. ``revision`` and ``delta`` are mutually exclusive.
""" """
# The one invariant we *know* holds is that the new (potentially # The one invariant we *know* holds is that the new (potentially
# bogus) DAG shape will be valid if we order the nodes in the # bogus) DAG shape will be valid if we order the nodes in the
# order that they're introduced in dramatis personae by the # order that they're introduced in dramatis personae by the
# changelog, so what we do is we sort the non-changelog histories # changelog, so what we do is we sort the non-changelog histories
# by the order in which they are used by the changelog. # by the order in which they are used by the changelog.
key = lambda n: cl.rev(lookup(n)) key = lambda n: cl.rev(lookup(n))
return [store.rev(n) for n in sorted(nodes, key=key)] return [store.rev(n) for n in sorted(nodes, key=key)]
def _revisiondeltanormal(store, rev, prev, linknode, forcedeltaparentprev): def _handlerevisiondeltarequest(store, request, prev):
"""Construct a revision delta for non-ellipses changegroup generation.""" """Obtain a revisiondelta from a revisiondeltarequest"""
node = store.node(rev)
p1, p2 = store.parentrevs(rev)
if forcedeltaparentprev: node = request.node
base = prev rev = store.rev(node)
# Requesting a full revision.
if request.baserev == nullrev:
base = nullrev
# Requesting an explicit revision.
elif request.baserev is not None:
base = request.baserev
# Allowing us to choose.
else: else:
p1, p2 = store.parentrevs(rev)
dp = store.deltaparent(rev) dp = store.deltaparent(rev)
if dp == nullrev and store.storedeltachains: if dp == nullrev and store.storedeltachains:
# Avoid sending full revisions when delta parent is null. Pick prev # Avoid sending full revisions when delta parent is null. Pick prev
# in that case. It's tempting to pick p1 in this case, as p1 will # in that case. It's tempting to pick p1 in this case, as p1 will
# be smaller in the common case. However, computing a delta against # be smaller in the common case. However, computing a delta against
# p1 may require resolving the raw text of p1, which could be # p1 may require resolving the raw text of p1, which could be
# expensive. The revlog caches should have prev cached, meaning # expensive. The revlog caches should have prev cached, meaning
if base != nullrev: if base != nullrev:
baserevisionsize = store.rawsize(base) baserevisionsize = store.rawsize(base)
elif base == nullrev: elif base == nullrev:
revision = store.revision(node, raw=True) revision = store.revision(node, raw=True)
else: else:
delta = store.revdiff(base, rev) delta = store.revdiff(base, rev)
p1n, p2n = store.parents(node) extraflags = revlog.REVIDX_ELLIPSIS if request.ellipsis else 0
return revisiondelta( return revisiondelta(
node=node, node=node,
p1node=p1n, p1node=request.p1node,
p2node=p2n, p2node=request.p2node,
linknode=request.linknode,
basenode=store.node(base), basenode=store.node(base),
linknode=linknode, flags=store.flags(rev) | extraflags,
flags=store.flags(rev),
baserevisionsize=baserevisionsize, baserevisionsize=baserevisionsize,
revision=revision, revision=revision,
delta=delta, delta=delta,
) )
def _revisiondeltanarrow(cl, store, ischangelog, rev, linkrev, def _makenarrowdeltarequest(cl, store, ischangelog, rev, node, linkrev,
linknode, clrevtolocalrev, fullclnodes, linknode, clrevtolocalrev, fullclnodes,
precomputedellipsis): precomputedellipsis):
linkparents = precomputedellipsis[linkrev] linkparents = precomputedellipsis[linkrev]
def local(clrev): def local(clrev):
"""Turn a changelog revnum into a local revnum. """Turn a changelog revnum into a local revnum.
The ellipsis dag is stored as revnums on the changelog, The ellipsis dag is stored as revnums on the changelog,
but when we're producing ellipsis entries for but when we're producing ellipsis entries for
non-changelog revlogs, we need to turn those numbers into non-changelog revlogs, we need to turn those numbers into
something local. This does that for us, and during the something local. This does that for us, and during the
store.parentrevs(rev) == (nullrev, nullrev)): store.parentrevs(rev) == (nullrev, nullrev)):
p1, p2 = nullrev, nullrev p1, p2 = nullrev, nullrev
elif len(linkparents) == 1: elif len(linkparents) == 1:
p1, = sorted(local(p) for p in linkparents) p1, = sorted(local(p) for p in linkparents)
p2 = nullrev p2 = nullrev
else: else:
p1, p2 = sorted(local(p) for p in linkparents) p1, p2 = sorted(local(p) for p in linkparents)
n = store.node(rev) p1node, p2node = store.node(p1), store.node(p2)
p1n, p2n = store.node(p1), store.node(p2)
flags = store.flags(rev)
flags |= revlog.REVIDX_ELLIPSIS
# TODO: try and actually send deltas for ellipsis data blocks # TODO: try and actually send deltas for ellipsis data blocks
return revisiondeltarequest(
return revisiondelta( node=node,
node=n, p1node=p1node,
p1node=p1n, p2node=p2node,
p2node=p2n,
basenode=nullid,
linknode=linknode, linknode=linknode,
flags=flags, baserev=nullrev,
baserevisionsize=None, ellipsis=True,
revision=store.revision(n),
delta=None,
) )
def deltagroup(repo, revs, store, ischangelog, lookup, forcedeltaparentprev, def deltagroup(repo, revs, store, ischangelog, lookup, forcedeltaparentprev,
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 revs:
return return
# We perform two passes over the revisions whose data we will emit.
#
# In the first pass, we obtain information about the deltas that will
# be generated. This involves computing linknodes and adjusting the
# request to take shallow fetching into account. The end result of
# this pass is a list of "request" objects stating which deltas
# to obtain.
#
# The second pass is simply resolving the requested deltas.
cl = repo.changelog cl = repo.changelog
# In the first pass, collect info about the deltas we'll be
# generating.
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])
# build deltas
progress = None
if units is not None:
progress = repo.ui.makeprogress(_('bundling'), unit=units,
total=(len(revs) - 1))
for i in pycompat.xrange(len(revs) - 1): for i in pycompat.xrange(len(revs) - 1):
if progress:
progress.update(i + 1)
prev = revs[i] prev = revs[i]
curr = revs[i + 1] curr = revs[i + 1]
linknode = lookup(store.node(curr)) node = store.node(curr)
linknode = lookup(node)
p1node, p2node = store.parents(node)
if ellipses: if ellipses:
linkrev = cl.rev(linknode) linkrev = cl.rev(linknode)
clrevtolocalrev[linkrev] = curr clrevtolocalrev[linkrev] = curr
# This is a node to send in full, because the changeset it # This is a node to send in full, because the changeset it
# corresponds to was a full changeset. # corresponds to was a full changeset.
if linknode in fullclnodes: if linknode in fullclnodes:
delta = _revisiondeltanormal(store, curr, prev, linknode, requests.append(revisiondeltarequest(
forcedeltaparentprev) node=node,
p1node=p1node,
p2node=p2node,
linknode=linknode,
baserev=None,
))
elif linkrev not in precomputedellipsis: elif linkrev not in precomputedellipsis:
delta = None pass
else: else:
delta = _revisiondeltanarrow( requests.append(_makenarrowdeltarequest(
cl, store, ischangelog, curr, linkrev, linknode, cl, store, ischangelog, curr, node, linkrev, linknode,
clrevtolocalrev, fullclnodes, clrevtolocalrev, fullclnodes,
precomputedellipsis) precomputedellipsis))
else: else:
delta = _revisiondeltanormal(store, curr, prev, linknode, requests.append(revisiondeltarequest(
forcedeltaparentprev) node=node,
p1node=p1node,
p2node=p2node,
linknode=linknode,
baserev=prev if forcedeltaparentprev else None,
))
# We expect the first pass to be fast, so we only engage the progress
# meter for constructing the revision deltas.
progress = None
if units is not None:
progress = repo.ui.makeprogress(_('bundling'), unit=units,
total=len(requests))
prevrev = revs[0]
for i, request in enumerate(requests):
if progress:
progress.update(i + 1)
delta = _handlerevisiondeltarequest(store, request, prevrev)
if delta:
yield delta yield delta
prevrev = store.rev(request.node)
if progress: if progress:
progress.complete() progress.complete()
class cgpacker(object): class cgpacker(object):
def __init__(self, repo, filematcher, version, allowreorder, def __init__(self, repo, filematcher, version, allowreorder,
builddeltaheader, manifestsend, builddeltaheader, manifestsend,
forcedeltaparentprev=False, forcedeltaparentprev=False,
bundlecaps=None, ellipses=False, bundlecaps=None, ellipses=False,