( )⚙ D1620 revset: use phasecache.getrevset to calculate public()

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1620

revset: use phasecache.getrevset to calculate public()
ClosedPublic

Authored by quark on Dec 8 2017, 5:47 PM.

Details

Reviewers
yuja
Group Reviewers
hg-reviewers
Commits
rHG0c1aff6d73a7: revset: use phasecache.getrevset to calculate public()
Summary

Other revsets like secret(), draft(), _nonpublic() are using
phasescache.getrevset already. The latter is more efficient after D1606.
So let's migrate the public() revset function too.

Tested using:

$ hg debugshell --hidden --cwd hg-committed`
In [1]: %timeit len(repo.revs('public()'))
  • Before D1606: 10 loops, best of 3: 22.5 ms per loop
  • Before this change, after D1606: 10 loops, best of 3: 28.6 ms per loop
  • After this change: 10 loops, best of 3: 20.2 ms per loop

Therefore public() revset becomes even slightly faster after the data
structure change by D1606. A similar performance win could also be observed
on a large repo.

A side effect is phasecache.getrevset needs to take a subset parameter.
That was added with a default value so it won't cause BC issues.

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

quark created this revision.Dec 8 2017, 5:47 PM
yuja accepted this revision.Dec 8 2017, 8:38 PM
This revision is now accepted and ready to land.Dec 8 2017, 8:38 PM
Closed by commit rHG0c1aff6d73a7: revset: use phasecache.getrevset to calculate public() (authored by quark). · Explain WhyDec 8 2017, 8:52 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/phases.py (13 lines)
Mmercurial/revset.py (9 lines)

Diff 4281

mercurial/phases.py

if _load: if _load:
# Cheap trick to allow shallow-copy without copy module # Cheap trick to allow shallow-copy without copy module
self.phaseroots, self.dirty = _readroots(repo, phasedefaults) self.phaseroots, self.dirty = _readroots(repo, phasedefaults)
self._phasemaxrev = nullrev self._phasemaxrev = nullrev
self._phasesets = None self._phasesets = None
self.filterunknown(repo) self.filterunknown(repo)
self.opener = repo.svfs self.opener = repo.svfs
def getrevset(self, repo, phases): def getrevset(self, repo, phases, subset=None):
"""return a smartset for the given phases""" """return a smartset for the given phases"""
self.loadphaserevs(repo) # ensure phase's sets are loaded self.loadphaserevs(repo) # ensure phase's sets are loaded
phases = set(phases) phases = set(phases)
if public not in phases: if public not in phases:
# fast path: _phasesets contains the interesting sets, # fast path: _phasesets contains the interesting sets,
# might only need a union and post-filtering. # might only need a union and post-filtering.
if len(phases) == 1: if len(phases) == 1:
[p] = phases [p] = phases
revs = self._phasesets[p] revs = self._phasesets[p]
else: else:
revs = set.union(*[self._phasesets[p] for p in phases]) revs = set.union(*[self._phasesets[p] for p in phases])
if repo.changelog.filteredrevs: if repo.changelog.filteredrevs:
revs = revs - repo.changelog.filteredrevs revs = revs - repo.changelog.filteredrevs
if subset is None:
return smartset.baseset(revs) return smartset.baseset(revs)
else: else:
return subset & smartset.baseset(revs)
else:
phases = set(allphases).difference(phases) phases = set(allphases).difference(phases)
if not phases: if not phases:
return smartset.fullreposet(repo) return smartset.fullreposet(repo)
if len(phases) == 1: if len(phases) == 1:
[p] = phases [p] = phases
revs = self._phasesets[p] revs = self._phasesets[p]
else: else:
revs = set.union(*[self._phasesets[p] for p in phases]) revs = set.union(*[self._phasesets[p] for p in phases])
if subset is None:
subset = smartset.fullreposet(repo)
if not revs: if not revs:
return smartset.fullreposet(repo) return subset
return smartset.fullreposet(repo).filter(lambda r: r not in revs) return subset.filter(lambda r: r not in revs)
def copy(self): def copy(self):
# Shallow copy meant to ensure isolation in # Shallow copy meant to ensure isolation in
# advance/retractboundary(), nothing more. # advance/retractboundary(), nothing more.
ph = self.__class__(None, None, _load=False) ph = self.__class__(None, None, _load=False)
ph.phaseroots = self.phaseroots[:] ph.phaseroots = self.phaseroots[:]
ph.dirty = self.dirty ph.dirty = self.dirty
ph.opener = self.opener ph.opener = self.opener

mercurial/revset.py

up(parentrevs(r)) up(parentrevs(r))
except error.WdirUnsupported: except error.WdirUnsupported:
up(p.rev() for p in repo[r].parents()) up(p.rev() for p in repo[r].parents())
ps -= {node.nullrev} ps -= {node.nullrev}
return subset & ps return subset & ps
def _phase(repo, subset, *targets): def _phase(repo, subset, *targets):
"""helper to select all rev in <targets> phases""" """helper to select all rev in <targets> phases"""
s = repo._phasecache.getrevset(repo, targets) return repo._phasecache.getrevset(repo, targets, subset)
return subset & s
@predicate('draft()', safe=True) @predicate('draft()', safe=True)
def draft(repo, subset, x): def draft(repo, subset, x):
"""Changeset in draft phase.""" """Changeset in draft phase."""
# i18n: "draft" is a keyword # i18n: "draft" is a keyword
getargs(x, 0, 0, _("draft takes no arguments")) getargs(x, 0, 0, _("draft takes no arguments"))
target = phases.draft target = phases.draft
return _phase(repo, subset, target) return _phase(repo, subset, target)
revs = revs.filter(lambda r: getphase(repo, r) == draft) revs = revs.filter(lambda r: getphase(repo, r) == draft)
return subset & revs return subset & revs
@predicate('public()', safe=True) @predicate('public()', safe=True)
def public(repo, subset, x): def public(repo, subset, x):
"""Changeset in public phase.""" """Changeset in public phase."""
# i18n: "public" is a keyword # i18n: "public" is a keyword
getargs(x, 0, 0, _("public takes no arguments")) getargs(x, 0, 0, _("public takes no arguments"))
phase = repo._phasecache.phase return _phase(repo, subset, phases.public)
target = phases.public
condition = lambda r: phase(repo, r) == target
return subset.filter(condition, condrepr=('<phase %r>', target),
cache=False)
@predicate('remote([id [,path]])', safe=False) @predicate('remote([id [,path]])', safe=False)
def remote(repo, subset, x): def remote(repo, subset, x):
"""Local revision that corresponds to the given identifier in a """Local revision that corresponds to the given identifier in a
remote repository, if present. Here, the '.' identifier is a remote repository, if present. Here, the '.' identifier is a
synonym for the current local branch. synonym for the current local branch.
""" """