This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6208

branchcache: lazily validate nodes from the branchmap
ClosedPublic

Authored by pulkit on Apr 5 2019, 9:31 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG6578654916ae: branchcache: lazily validate nodes from the branchmap
Summary

On my personal hg-repository with 365 entries in .hg/cache/branch2, following
are the numbers for perfbranchmapload.

Before this patch:

! wall 0.000866 comb 0.000000 user 0.000000 sys 0.000000 (best of 2680)
! wall 0.001525 comb 0.000000 user 0.000000 sys 0.000000 (max of 2680)
! wall 0.001107 comb 0.001097 user 0.001086 sys 0.000011 (avg of 2680)
! wall 0.001104 comb 0.000000 user 0.000000 sys 0.000000 (median of 2680)

With this patch:

! wall 0.000530 comb 0.000000 user 0.000000 sys 0.000000 (best of 4240)
! wall 0.001078 comb 0.000000 user 0.000000 sys 0.000000 (max of 4240)
! wall 0.000696 comb 0.000693 user 0.000677 sys 0.000017 (avg of 4240)
! wall 0.000690 comb 0.000000 user 0.000000 sys 0.000000 (median of 4240)

On our internal repository with ~20k entries in branchcache, I see improvement
from 0.125 sec to 0.066 sec which is 47% speed up.

The above are the numbers of perfbranchmapload which shows how much time we
saved by not validating the nodes. But we need to validate some nodes. Following
are timings of some mercurial operations which have speed up because of this
lazy validation of nodes:

No-op hg update on our internal repository (Avg on 4 runs):

Before: 0.540 secs
After: 0.430 secs

Setting a branch name which already exists without --force (Avg of 4 runs):

Before: 0.510 secs
After: 0.250 secs

I ran the ASV performance suite and was unable to see any improvements except
there was improvement of perfdirstatewrite() on netbeans which I think was not
related.

I looked into the commit code, the command which I am trying to speedup, it
looks like it uses revbranchcache to update the branchcache.

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

pulkit created this revision.Apr 5 2019, 9:31 AM
yuja added a subscriber: yuja.Apr 12 2019, 9:12 PM

The idea sounds good to me. Is this still an RFC (i.e. draft) patch?

pulkit retitled this revision from [RFC] branchmap: lazily validate nodes from the branchmap to branchcache: lazily validate nodes from the branchmap.Apr 15 2019, 12:14 PM
pulkit added a comment.Apr 15 2019, 12:29 PM
In D6208#90673, @yuja wrote:

The idea sounds good to me. Is this still an RFC (i.e. draft) patch?

It's good to be reviewed.

yuja added a comment.Apr 15 2019, 7:16 PM
def copy(self):
    """return an deep copy of the branchcache object"""

+ self._verifyall()

return type(self)(
    self._entries, self.tipnode, self.tiprev, self.filteredhash,
    self._closednodes)

Maybe the copy would be marked as not verified?

Closed by commit rHG6578654916ae: branchcache: lazily validate nodes from the branchmap (authored by pulkit). · Explain WhyApr 15 2019, 7:41 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/branchmap.py (15 lines)

Diff 14751

mercurial/branchmap.py

def __iter__(self): def __iter__(self):
return iter(self._entries) return iter(self._entries)
def __setitem__(self, key, value): def __setitem__(self, key, value):
self._entries[key] = value self._entries[key] = value
def __getitem__(self, key): def __getitem__(self, key):
self._verifybranch(key)
return self._entries[key] return self._entries[key]
def __contains__(self, key): def __contains__(self, key):
self._verifybranch(key)
return key in self._entries return key in self._entries
def iteritems(self): def iteritems(self):
self._verifyall()
return self._entries.iteritems() return self._entries.iteritems()
def hasbranch(self, label): def hasbranch(self, label):
""" checks whether a branch of this name exists or not """ """ checks whether a branch of this name exists or not """
self._verifybranch(label)
return label in self._entries return label in self._entries
@classmethod @classmethod
def fromfile(cls, repo): def fromfile(cls, repo):
f = None f = None
try: try:
f = repo.cachevfs(cls._filename(repo)) f = repo.cachevfs(cls._filename(repo))
lineiter = iter(f) lineiter = iter(f)
if f: if f:
f.close() f.close()
return bcache return bcache
def load(self, repo, lineiter): def load(self, repo, lineiter):
""" fully loads the branchcache by reading from the file using the line """ fully loads the branchcache by reading from the file using the line
iterator passed""" iterator passed"""
cl = repo.changelog
for line in lineiter: for line in lineiter:
line = line.rstrip('\n') line = line.rstrip('\n')
if not line: if not line:
continue continue
node, state, label = line.split(" ", 2) node, state, label = line.split(" ", 2)
if state not in 'oc': if state not in 'oc':
raise ValueError(r'invalid branch state') raise ValueError(r'invalid branch state')
label = encoding.tolocal(label.strip()) label = encoding.tolocal(label.strip())
node = bin(node) node = bin(node)
if not cl.hasnode(node):
raise ValueError(
r'node %s does not exist' % pycompat.sysstr(hex(node)))
self._entries.setdefault(label, []).append(node) self._entries.setdefault(label, []).append(node)
self._verifiedbranches.add(label)
if state == 'c': if state == 'c':
self._closednodes.add(node) self._closednodes.add(node)
self._closedverified = True
@staticmethod @staticmethod
def _filename(repo): def _filename(repo):
"""name of a branchcache file for a given repo or repoview""" """name of a branchcache file for a given repo or repoview"""
filename = "branch2" filename = "branch2"
if repo.filtername: if repo.filtername:
filename = '%s-%s' % (filename, repo.filtername) filename = '%s-%s' % (filename, repo.filtername)
return filename return filename
except IndexError: except IndexError:
return False return False
def _branchtip(self, heads): def _branchtip(self, heads):
'''Return tuple with last open head in heads and false, '''Return tuple with last open head in heads and false,
otherwise return last closed head and true.''' otherwise return last closed head and true.'''
tip = heads[-1] tip = heads[-1]
closed = True closed = True
self._verifyclosed()
for h in reversed(heads): for h in reversed(heads):
if h not in self._closednodes: if h not in self._closednodes:
tip = h tip = h
closed = False closed = False
break break
return tip, closed return tip, closed
def branchtip(self, branch): def branchtip(self, branch):
'''Return the tipmost open head on branch head, otherwise return the '''Return the tipmost open head on branch head, otherwise return the
tipmost closed head on branch. tipmost closed head on branch.
Raise KeyError for unknown branch.''' Raise KeyError for unknown branch.'''
return self._branchtip(self[branch])[0] return self._branchtip(self[branch])[0]
def iteropen(self, nodes): def iteropen(self, nodes):
self._verifyclosed()
return (n for n in nodes if n not in self._closednodes) return (n for n in nodes if n not in self._closednodes)
def branchheads(self, branch, closed=False): def branchheads(self, branch, closed=False):
self._verifybranch(branch)
heads = self._entries[branch] heads = self._entries[branch]
if not closed: if not closed:
heads = list(self.iteropen(heads)) heads = list(self.iteropen(heads))
return heads return heads
def iterbranches(self): def iterbranches(self):
for bn, heads in self.iteritems(): for bn, heads in self.iteritems():
yield (bn, heads) + self._branchtip(heads) yield (bn, heads) + self._branchtip(heads)
def iterheads(self): def iterheads(self):
""" returns all the heads """ """ returns all the heads """
self._verifyall()
return self._entries.itervalues() return self._entries.itervalues()
def copy(self): def copy(self):
"""return an deep copy of the branchcache object""" """return an deep copy of the branchcache object"""
self._verifyall()
return type(self)( return type(self)(
self._entries, self.tipnode, self.tiprev, self.filteredhash, self._entries, self.tipnode, self.tiprev, self.filteredhash,
self._closednodes) self._closednodes)
def write(self, repo): def write(self, repo):
try: try:
f = repo.cachevfs(self._filename(repo), "w", atomictemp=True) f = repo.cachevfs(self._filename(repo), "w", atomictemp=True)
cachekey = [hex(self.tipnode), '%d' % self.tiprev] cachekey = [hex(self.tipnode), '%d' % self.tiprev]