This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5301

store: append to fncache if there are only new files to write
ClosedPublic

Authored by pulkit on Nov 26 2018, 7:02 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG0728d87a8631: store: append to fncache if there are only new files to write
Summary

Before this patch, if we have to add a new entry to fncache, we write the whole
fncache again which slows things down on large fncache which have millions of
entries. Addition of a new entry is common operation while pulling new files or
commiting a new file.

This patch adds a new fncache.addls set which keeps track of the additions
happening and store them. When we write the fncache, we will just read the addls
set and append those entries at the end of fncache.
We make sure that the entries are new entries by loading the fncache and making
sure entry does not exists there. In future if we can check if an entry is new
without loading the fncache, that will speed up things more.

Performance numbers for commiting a new file:

mercurial repo
before: 0.08784651756286621
after: 0.08474504947662354

mozilla-central
before: 1.83314049243927
after: 1.7054164409637451

netbeans
before: 0.7953150272369385
after: 0.7202838659286499

pypy
before: 0.17805707454681396
after: 0.13431048393249512

In our internal repo, the performance improvement is in seconds.

I have used octobus's ASV perf benchmark thing to get the above numbers. I also
see some minute perf improvements related to creating a new commit without a new
file, but I believe that's just some noise.

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.Nov 26 2018, 7:02 AM
Closed by commit rHG0728d87a8631: store: append to fncache if there are only new files to write (authored by pulkit). · Explain WhyNov 26 2018, 6:06 PM
This revision was automatically updated to reflect the committed changes.
yuja added a subscriber: yuja.Nov 27 2018, 7:24 AM

@@ -479,32 +481,45 @@

    fp.write(encodedir('\n'.join(self.entries) + '\n'))
fp.close()
self._dirty = False

+ if self.addls:
+ # if we have just new entries, let's append them to the fncache
+ tr.addbackup('fncache')
+ fp = self.vfs('fncache', mode='ab', atomictemp=True)
+ if self.addls:
+ fp.write(encodedir('\n'.join(self.addls) + '\n'))
+ fp.close()
+ self.entries = None
+ self.addls = set()

It's probably better to write entries | addls at once if there are both
adds and removes. Appending to an atomictemp file means the entire file
is copied first.

Revision Contents
Changeset List

PathPackages
Mmercurial/store.py (22 lines)

Diff 12605

mercurial/store.py

class fncache(object): class fncache(object):
# the filename used to be partially encoded # the filename used to be partially encoded
# hence the encodedir/decodedir dance # hence the encodedir/decodedir dance
def __init__(self, vfs): def __init__(self, vfs):
self.vfs = vfs self.vfs = vfs
self.entries = None self.entries = None
self._dirty = False self._dirty = False
# set of new additions to fncache
self.addls = set()
def _load(self): def _load(self):
'''fill the entries from the fncache file''' '''fill the entries from the fncache file'''
self._dirty = False self._dirty = False
try: try:
fp = self.vfs('fncache', mode='rb') fp = self.vfs('fncache', mode='rb')
except IOError: except IOError:
# skip nonexistent file # skip nonexistent file
if self._dirty: if self._dirty:
assert self.entries is not None assert self.entries is not None
tr.addbackup('fncache') tr.addbackup('fncache')
fp = self.vfs('fncache', mode='wb', atomictemp=True) fp = self.vfs('fncache', mode='wb', atomictemp=True)
if self.entries: if self.entries:
fp.write(encodedir('\n'.join(self.entries) + '\n')) fp.write(encodedir('\n'.join(self.entries) + '\n'))
fp.close() fp.close()
self._dirty = False self._dirty = False
if self.addls:
# if we have just new entries, let's append them to the fncache
tr.addbackup('fncache')
fp = self.vfs('fncache', mode='ab', atomictemp=True)
if self.addls:
fp.write(encodedir('\n'.join(self.addls) + '\n'))
fp.close()
self.entries = None
self.addls = set()
def add(self, fn): def add(self, fn):
if self.entries is None: if self.entries is None:
self._load() self._load()
if fn not in self.entries: if fn not in self.entries:
self._dirty = True self.addls.add(fn)
self.entries.add(fn)
def remove(self, fn): def remove(self, fn):
if self.entries is None: if self.entries is None:
self._load() self._load()
if fn in self.addls:
self.addls.remove(fn)
return
try: try:
self.entries.remove(fn) self.entries.remove(fn)
self._dirty = True self._dirty = True
except KeyError: except KeyError:
pass pass
def __contains__(self, fn): def __contains__(self, fn):
if fn in self.addls:
return True
if self.entries is None: if self.entries is None:
self._load() self._load()
return fn in self.entries return fn in self.entries
def __iter__(self): def __iter__(self):
if self.entries is None: if self.entries is None:
self._load() self._load()
return iter(self.entries) return iter(self.entries | self.addls)
class _fncachevfs(vfsmod.abstractvfs, vfsmod.proxyvfs): class _fncachevfs(vfsmod.abstractvfs, vfsmod.proxyvfs):
def __init__(self, vfs, fnc, encode): def __init__(self, vfs, fnc, encode):
vfsmod.proxyvfs.__init__(self, vfs) vfsmod.proxyvfs.__init__(self, vfs)
self.fncache = fnc self.fncache = fnc
self.encode = encode self.encode = encode
def __call__(self, path, mode='r', *args, **kw): def __call__(self, path, mode='r', *args, **kw):
return (['requires', '00changelog.i'] + return (['requires', '00changelog.i'] +
['store/' + f for f in d.split()]) ['store/' + f for f in d.split()])
def write(self, tr): def write(self, tr):
self.fncache.write(tr) self.fncache.write(tr)
def invalidatecaches(self): def invalidatecaches(self):
self.fncache.entries = None self.fncache.entries = None
self.fncache.addls = set()
def markremoved(self, fn): def markremoved(self, fn):
self.fncache.remove(fn) self.fncache.remove(fn)
def _exists(self, f): def _exists(self, f):
ef = self.encode(f) ef = self.encode(f)
try: try:
self.getsize(ef) self.getsize(ef)