This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4216

changegroup: capture base node instead of rev in delta request
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd0d197ab0646: changegroup: capture base node instead of rev in delta request
Summary

I want the API in storage to be defined in terms of nodes, not
revision numbers.

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, 4:52 PM
Closed by commit rHGd0d197ab0646: changegroup: capture base node instead of rev in delta request (authored by indygreg). · Explain WhyAug 9 2018, 10:24 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (56 lines)

Diff 10240

mercurial/changegroup.py

# Linknode value. # Linknode value.
linknode = attr.ib() linknode = attr.ib()
# Parent revisions to record in ``revisiondelta`` instance. # Parent revisions to record in ``revisiondelta`` instance.
p1node = attr.ib() p1node = attr.ib()
p2node = attr.ib() p2node = attr.ib()
# Base revision that delta should be generated against. If nullrev, # Base revision that delta should be generated against. If nullid,
# the full revision data should be populated. If None, the delta # the full revision data should be populated. If None, the delta
# may be generated against any base revision that is an ancestor of # may be generated against any base revision that is an ancestor of
# this revision. If any other numeric value, the delta should be # this revision. If any other value, the delta should be produced
# produced against that revision. # against that revision.
baserev = attr.ib() basenode = attr.ib()
# Whether this should be marked as an ellipsis revision. # Whether this should be marked as an ellipsis revision.
ellipsis = attr.ib(default=False) ellipsis = attr.ib(default=False)
@attr.s(slots=True, frozen=True) @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.
# 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 _handlerevisiondeltarequest(store, request, prev): def _handlerevisiondeltarequest(store, request, prevnode):
"""Obtain a revisiondelta from a revisiondeltarequest""" """Obtain a revisiondelta from a revisiondeltarequest"""
node = request.node node = request.node
rev = store.rev(node) rev = store.rev(node)
# Requesting a full revision. # Requesting a full revision.
if request.baserev == nullrev: if request.basenode == nullid:
base = nullrev baserev = nullrev
# Requesting an explicit revision. # Requesting an explicit revision.
elif request.baserev is not None: elif request.basenode is not None:
base = request.baserev baserev = store.rev(request.basenode)
# Allowing us to choose. # Allowing us to choose.
else: else:
p1, p2 = store.parentrevs(rev) 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
# less CPU for changegroup generation. There is likely room to add # less CPU for changegroup generation. There is likely room to add
# a flag and/or config option to control this behavior. # a flag and/or config option to control this behavior.
base = prev baserev = store.rev(prevnode)
elif dp == nullrev: elif dp == nullrev:
# revlog is configured to use full snapshot for a reason, # revlog is configured to use full snapshot for a reason,
# stick to full snapshot. # stick to full snapshot.
base = nullrev baserev = nullrev
elif dp not in (p1, p2, prev): elif dp not in (p1, p2, store.rev(prevnode)):
# Pick prev when we can't be sure remote has the base revision. # Pick prev when we can't be sure remote has the base revision.
base = prev baserev = store.rev(prevnode)
else: else:
base = dp baserev = dp
if base != nullrev and not store.candelta(base, rev): if baserev != nullrev and not store.candelta(baserev, rev):
base = nullrev baserev = nullrev
revision = None revision = None
delta = None delta = None
baserevisionsize = None baserevisionsize = None
if store.iscensored(base) or store.iscensored(rev): if store.iscensored(baserev) or store.iscensored(rev):
try: try:
revision = store.revision(node, raw=True) revision = store.revision(node, raw=True)
except error.CensoredNodeError as e: except error.CensoredNodeError as e:
revision = e.tombstone revision = e.tombstone
if base != nullrev: if baserev != nullrev:
baserevisionsize = store.rawsize(base) baserevisionsize = store.rawsize(baserev)
elif base == nullrev: elif baserev == nullrev:
revision = store.revision(node, raw=True) revision = store.revision(node, raw=True)
else: else:
delta = store.revdiff(base, rev) delta = store.revdiff(baserev, rev)
extraflags = revlog.REVIDX_ELLIPSIS if request.ellipsis else 0 extraflags = revlog.REVIDX_ELLIPSIS if request.ellipsis else 0
return revisiondelta( return revisiondelta(
node=node, node=node,
p1node=request.p1node, p1node=request.p1node,
p2node=request.p2node, p2node=request.p2node,
linknode=request.linknode, linknode=request.linknode,
basenode=store.node(base), basenode=store.node(baserev),
flags=store.flags(rev) | extraflags, flags=store.flags(rev) | extraflags,
baserevisionsize=baserevisionsize, baserevisionsize=baserevisionsize,
revision=revision, revision=revision,
delta=delta, delta=delta,
) )
def _makenarrowdeltarequest(cl, store, ischangelog, rev, node, linkrev, def _makenarrowdeltarequest(cl, store, ischangelog, rev, node, linkrev,
linknode, clrevtolocalrev, fullclnodes, linknode, clrevtolocalrev, fullclnodes,
p1node, p2node = store.node(p1), store.node(p2) p1node, p2node = store.node(p1), store.node(p2)
# TODO: try and actually send deltas for ellipsis data blocks # TODO: try and actually send deltas for ellipsis data blocks
return revisiondeltarequest( return revisiondeltarequest(
node=node, node=node,
p1node=p1node, p1node=p1node,
p2node=p2node, p2node=p2node,
linknode=linknode, linknode=linknode,
baserev=nullrev, basenode=nullid,
ellipsis=True, ellipsis=True,
) )
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.
# 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:
requests.append(revisiondeltarequest( requests.append(revisiondeltarequest(
node=node, node=node,
p1node=p1node, p1node=p1node,
p2node=p2node, p2node=p2node,
linknode=linknode, linknode=linknode,
baserev=None, basenode=None,
)) ))
elif linkrev not in precomputedellipsis: elif linkrev not in precomputedellipsis:
pass pass
else: else:
requests.append(_makenarrowdeltarequest( requests.append(_makenarrowdeltarequest(
cl, store, ischangelog, curr, node, linkrev, linknode, cl, store, ischangelog, curr, node, linkrev, linknode,
clrevtolocalrev, fullclnodes, clrevtolocalrev, fullclnodes,
precomputedellipsis)) precomputedellipsis))
else: else:
requests.append(revisiondeltarequest( requests.append(revisiondeltarequest(
node=node, node=node,
p1node=p1node, p1node=p1node,
p2node=p2node, p2node=p2node,
linknode=linknode, linknode=linknode,
baserev=prev if forcedeltaparentprev else None, basenode=store.node(prev) if forcedeltaparentprev else None,
)) ))
# We expect the first pass to be fast, so we only engage the progress # We expect the first pass to be fast, so we only engage the progress
# meter for constructing the revision deltas. # meter for constructing the revision deltas.
progress = None progress = None
if units is not None: if units is not None:
progress = repo.ui.makeprogress(_('bundling'), unit=units, progress = repo.ui.makeprogress(_('bundling'), unit=units,
total=len(requests)) total=len(requests))
prevrev = revs[0] prevnode = store.node(revs[0])
for i, request in enumerate(requests): for i, request in enumerate(requests):
if progress: if progress:
progress.update(i + 1) progress.update(i + 1)
delta = _handlerevisiondeltarequest(store, request, prevrev) delta = _handlerevisiondeltarequest(store, request, prevnode)
yield delta yield delta
prevrev = store.rev(request.node) prevnode = 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,