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
Lint Skipped
Unit
Unit Tests Skipped

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 10210

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,