This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4329

dagop: port revlogdag.linearize() to standalone function
ClosedPublic

Authored by indygreg on Aug 17 2018, 5:31 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG0a934ee94f09: dagop: port revlogdag.linearize() to standalone function
Summary

The code should functionally be identical.

We also port the one consumer in changegroup to use the new
standalone function.

After this commit, dagutil is no longer used!

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 17 2018, 5:31 PM
Closed by commit rHG0a934ee94f09: dagop: port revlogdag.linearize() to standalone function (authored by indygreg). · Explain WhyAug 18 2018, 4:07 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (6 lines)
Mmercurial/dagop.py (37 lines)

Diff 10450

mercurial/changegroup.py

short, short,
) )
from .thirdparty import ( from .thirdparty import (
attr, attr,
) )
from . import ( from . import (
dagutil, dagop,
error, error,
match as matchmod, match as matchmod,
mdiff, mdiff,
phases, phases,
pycompat, pycompat,
repository, repository,
revlog, revlog,
util, util,
yield prefix yield prefix
yield data yield data
def _sortnodesnormal(store, nodes, reorder): def _sortnodesnormal(store, nodes, reorder):
"""Sort nodes for changegroup generation and turn into revnums.""" """Sort nodes for changegroup generation and turn into revnums."""
# for generaldelta revlogs, we linearize the revs; this will both be # for generaldelta revlogs, we linearize the revs; this will both be
# much quicker and generate a much smaller bundle # much quicker and generate a much smaller bundle
if (store._generaldelta and reorder is None) or reorder: if (store._generaldelta and reorder is None) or reorder:
dag = dagutil.revlogdag(store) revs = set(store.rev(n) for n in nodes)
return dag.linearize(set(store.rev(n) for n in nodes)) return dagop.linearize(revs, store.parentrevs)
else: else:
return sorted([store.rev(n) for n in nodes]) return sorted([store.rev(n) for n in nodes])
def _sortnodesellipsis(store, nodes, cl, lookup): def _sortnodesellipsis(store, nodes, cl, lookup):
"""Sort nodes for changegroup generation and turn into revnums.""" """Sort nodes for changegroup generation and turn into revnums."""
# Ellipses serving mode. # Ellipses serving mode.
# #
# In a perfect world, we'd generate better ellipsis-ified graphs # In a perfect world, we'd generate better ellipsis-ified graphs

mercurial/dagop.py

for rev in revs: for rev in revs:
for prev in parentsfn(rev): for prev in parentsfn(rev):
headrevs.discard(prev) headrevs.discard(prev)
headrevs.discard(node.nullrev) headrevs.discard(node.nullrev)
return headrevs return headrevs
def linearize(revs, parentsfn):
"""Linearize and topologically sort a list of revisions.
The linearization process tires to create long runs of revs where a child
rev comes immediately after its first parent. This is done by visiting the
heads of the revs in inverse topological order, and for each visited rev,
visiting its second parent, then its first parent, then adding the rev
itself to the output list.
Returns a list of revision numbers.
"""
visit = list(sorted(headrevs(revs, parentsfn), reverse=True))
finished = set()
result = []
while visit:
rev = visit.pop()
if rev < 0:
rev = -rev - 1
if rev not in finished:
result.append(rev)
finished.add(rev)
else:
visit.append(-rev - 1)
for prev in parentsfn(rev):
if prev == node.nullrev or prev not in revs or prev in finished:
continue
visit.append(prev)
assert len(result) == len(revs)
return result