This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1730

repoview: store visibility exceptions for the filter in filtertable
AbandonedPublic

Authored by pulkit on Dec 19 2017, 7:09 AM.

Details

Reviewers
yuja
Group Reviewers
hg-reviewers
Summary

Earlier, filtertable contains the filtername and the corresponding function to
calculate filtered set for that filter. This patch make filtertable also store
the visibility exceptions for that filter. filtertable was a dictionary with
filtername as the key and function as the value, after this patch, the value is
a tuple of form (fn, visibilityexceptions).

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

pulkit created this revision.Dec 19 2017, 7:09 AM
yuja requested changes to this revision.Dec 19 2017, 9:05 AM
yuja added a subscriber: yuja.
yuja added inline comments.
mercurial/repoview.py
145

So this is global across repositories and permanently cached.

Can't we store the "exceptions" in repoview? I think their lifetime
should be the same.

This revision now requires changes to proceed.Dec 19 2017, 9:05 AM
pulkit abandoned this revision.Jan 10 2018, 3:51 AM

Revision Contents
Changeset List

PathPackages
Mmercurial/repoview.py (25 lines)

Diff 4549

mercurial/repoview.py

""" """
stack = list(revs) stack = list(revs)
while stack: while stack:
for p in pfunc(stack.pop()): for p in pfunc(stack.pop()):
if p != nullrev and p in hidden: if p != nullrev and p in hidden:
hidden.remove(p) hidden.remove(p)
stack.append(p) stack.append(p)
def computehidden(repo): def computehidden(repo, visibilityexceptions=None):
"""compute the set of hidden revision to filter """compute the set of hidden revision to filter
During most operation hidden should be filtered.""" During most operation hidden should be filtered."""
assert not repo.changelog.filteredrevs assert not repo.changelog.filteredrevs
hidden = hideablerevs(repo) hidden = hideablerevs(repo)
if hidden: if hidden:
hidden = set(hidden - pinnedrevs(repo)) hidden = set(hidden - pinnedrevs(repo))
if visibilityexceptions:
hidden -= visibilityexceptions
pfunc = repo.changelog.parentrevs pfunc = repo.changelog.parentrevs
mutablephases = (phases.draft, phases.secret) mutablephases = (phases.draft, phases.secret)
mutable = repo._phasecache.getrevset(repo, mutablephases) mutable = repo._phasecache.getrevset(repo, mutablephases)
visible = mutable - hidden visible = mutable - hidden
_revealancestors(pfunc, hidden, visible) _revealancestors(pfunc, hidden, visible)
return frozenset(hidden) return frozenset(hidden)
def computeunserved(repo): def computeunserved(repo, visibilityexceptions=None):
"""compute the set of revision that should be filtered when used a server """compute the set of revision that should be filtered when used a server
Secret and hidden changeset should not pretend to be here.""" Secret and hidden changeset should not pretend to be here."""
assert not repo.changelog.filteredrevs assert not repo.changelog.filteredrevs
# fast path in simple case to avoid impact of non optimised code # fast path in simple case to avoid impact of non optimised code
hiddens = filterrevs(repo, 'visible') hiddens = filterrevs(repo, 'visible')
if phases.hassecret(repo): if phases.hassecret(repo):
cl = repo.changelog cl = repo.changelog
secret = phases.secret secret = phases.secret
getphase = repo._phasecache.phase getphase = repo._phasecache.phase
first = min(cl.rev(n) for n in repo._phasecache.phaseroots[secret]) first = min(cl.rev(n) for n in repo._phasecache.phaseroots[secret])
revs = cl.revs(start=first) revs = cl.revs(start=first)
secrets = set(r for r in revs if getphase(repo, r) >= secret) secrets = set(r for r in revs if getphase(repo, r) >= secret)
return frozenset(hiddens | secrets) return frozenset(hiddens | secrets)
else: else:
return hiddens return hiddens
def computemutable(repo): def computemutable(repo, visibilityexceptions=None):
assert not repo.changelog.filteredrevs assert not repo.changelog.filteredrevs
# fast check to avoid revset call on huge repo # fast check to avoid revset call on huge repo
if any(repo._phasecache.phaseroots[1:]): if any(repo._phasecache.phaseroots[1:]):
getphase = repo._phasecache.phase getphase = repo._phasecache.phase
maymutable = filterrevs(repo, 'base') maymutable = filterrevs(repo, 'base')
return frozenset(r for r in maymutable if getphase(repo, r)) return frozenset(r for r in maymutable if getphase(repo, r))
return frozenset() return frozenset()
def computeimpactable(repo): def computeimpactable(repo, visibilityexceptions=None):
"""Everything impactable by mutable revision """Everything impactable by mutable revision
The immutable filter still have some chance to get invalidated. This will The immutable filter still have some chance to get invalidated. This will
happen when: happen when:
- you garbage collect hidden changeset, - you garbage collect hidden changeset,
- public phase is moved backward, - public phase is moved backward,
- something is changed in the filtering (this could be fixed) - something is changed in the filtering (this could be fixed)
This filter out any mutable changeset and any public changeset that may be This filter out any mutable changeset and any public changeset that may be
impacted by something happening to a mutable revision. impacted by something happening to a mutable revision.
This is achieved by filtered everything with a revision number egal or This is achieved by filtered everything with a revision number egal or
higher than the first mutable changeset is filtered.""" higher than the first mutable changeset is filtered."""
assert not repo.changelog.filteredrevs assert not repo.changelog.filteredrevs
cl = repo.changelog cl = repo.changelog
firstmutable = len(cl) firstmutable = len(cl)
for roots in repo._phasecache.phaseroots[1:]: for roots in repo._phasecache.phaseroots[1:]:
if roots: if roots:
firstmutable = min(firstmutable, min(cl.rev(r) for r in roots)) firstmutable = min(firstmutable, min(cl.rev(r) for r in roots))
# protect from nullrev root # protect from nullrev root
firstmutable = max(0, firstmutable) firstmutable = max(0, firstmutable)
return frozenset(xrange(firstmutable, len(cl))) return frozenset(xrange(firstmutable, len(cl)))
# function to compute filtered set # function and visibility exceptions to compute filtered set
# #
# When adding a new filter you MUST update the table at: # When adding a new filter you MUST update the table at:
# mercurial.branchmap.subsettable # mercurial.branchmap.subsettable
# Otherwise your filter will have to recompute all its branches cache # Otherwise your filter will have to recompute all its branches cache
# from scratch (very slow). # from scratch (very slow).
filtertable = {'visible': computehidden, filtertable = {'visible': (computehidden, set()),
yujaUnsubmitted
Not Done

So this is global across repositories and permanently cached.

Can't we store the "exceptions" in repoview? I think their lifetime
should be the same.

yuja: So this is global across repositories and permanently cached. Can't we store the "exceptions"…
'served': computeunserved, 'served': (computeunserved, set()),
'immutable': computemutable, 'immutable': (computemutable, set()),
'base': computeimpactable} 'base': (computeimpactable, set())}
def filterrevs(repo, filtername): def filterrevs(repo, filtername):
"""returns set of filtered revision for this filter name""" """returns set of filtered revision for this filter name"""
if filtername not in repo.filteredrevcache: if filtername not in repo.filteredrevcache:
func = filtertable[filtername] func, visibilityexceptions = filtertable[filtername]
repo.filteredrevcache[filtername] = func(repo.unfiltered()) repo.filteredrevcache[filtername] = func(repo.unfiltered(),
visibilityexceptions)
return repo.filteredrevcache[filtername] return repo.filteredrevcache[filtername]
class repoview(object): class repoview(object):
"""Provide a read/write view of a repo through a filtered changelog """Provide a read/write view of a repo through a filtered changelog
This object is used to access a filtered version of a repository without This object is used to access a filtered version of a repository without
altering the original repository object itself. We can not alter the altering the original repository object itself. We can not alter the
original object for two main reasons: original object for two main reasons: