This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12128

branchmap: stop writing cache for uncommitted data
ClosedPublic

Authored by marmoute on Feb 1 2022, 11:51 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG8e5effbf52d0: branchmap: stop writing cache for uncommitted data
Summary

If we are about to write the branch while a transaction is active. we delay
that write. After the transaction is closed, we flush all the write we delayed
(unless they have been written in between).

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

marmoute created this revision.Feb 1 2022, 11:51 AM
Alphare accepted this revision.Feb 2 2022, 5:04 AM
This revision is now accepted and ready to land.Feb 2 2022, 5:04 AM
marmoute added a commit: rHG8e5effbf52d0: branchmap: stop writing cache for uncommitted data.Feb 2 2022, 5:53 AM
Closed by commit rHG8e5effbf52d0: branchmap: stop writing cache for uncommitted data (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/branchmap.py (16 lines)
Mmercurial/localrepo.py (2 lines)
Mtests/test-branches.t (6 lines)

Diff 32031

mercurial/branchmap.py

if cache.validfor(rview): if cache.validfor(rview):
self._per_filter[candidate] = cache self._per_filter[candidate] = cache
cache.write(rview) cache.write(rview)
return return
def clear(self): def clear(self):
self._per_filter.clear() self._per_filter.clear()
def write_delayed(self, repo):
unfi = repo.unfiltered()
for filtername, cache in self._per_filter.items():
if cache._delayed:
repo = unfi.filtered(filtername)
cache.write(repo)
def _unknownnode(node): def _unknownnode(node):
"""raises ValueError when branchcache found a node which does not exists""" """raises ValueError when branchcache found a node which does not exists"""
raise ValueError('node %s does not exist' % pycompat.sysstr(hex(node))) raise ValueError('node %s does not exist' % pycompat.sysstr(hex(node)))
def _branchcachedesc(repo): def _branchcachedesc(repo):
if repo.filtername is not None: if repo.filtername is not None:
closednodes=None, closednodes=None,
hasnode=None, hasnode=None,
): ):
# type: (localrepo.localrepository, Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None # type: (localrepo.localrepository, Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None
"""hasnode is a function which can be used to verify whether changelog """hasnode is a function which can be used to verify whether changelog
has a given node or not. If it's not provided, we assume that every node has a given node or not. If it's not provided, we assume that every node
we have exists in changelog""" we have exists in changelog"""
self._repo = repo self._repo = repo
self._delayed = False
if tipnode is None: if tipnode is None:
self.tipnode = repo.nullid self.tipnode = repo.nullid
else: else:
self.tipnode = tipnode self.tipnode = tipnode
self.tiprev = tiprev self.tiprev = tiprev
self.filteredhash = filteredhash self.filteredhash = filteredhash
# closednodes is a set of nodes that close their branch. If the branch # closednodes is a set of nodes that close their branch. If the branch
# cache has been updated, it may contain nodes that are no longer # cache has been updated, it may contain nodes that are no longer
self._entries, self._entries,
self.tipnode, self.tipnode,
self.tiprev, self.tiprev,
self.filteredhash, self.filteredhash,
self._closednodes, self._closednodes,
) )
def write(self, repo): def write(self, repo):
tr = repo.currenttransaction()
if not getattr(tr, 'finalized', True):
# Avoid premature writing.
#
# (The cache warming setup by localrepo will update the file later.)
self._delayed = True
return
try: try:
f = repo.cachevfs(self._filename(repo), b"w", atomictemp=True) f = repo.cachevfs(self._filename(repo), b"w", atomictemp=True)
cachekey = [hex(self.tipnode), b'%d' % self.tiprev] cachekey = [hex(self.tipnode), b'%d' % self.tiprev]
if self.filteredhash is not None: if self.filteredhash is not None:
cachekey.append(hex(self.filteredhash)) cachekey.append(hex(self.filteredhash))
f.write(b" ".join(cachekey) + b'\n') f.write(b" ".join(cachekey) + b'\n')
nodecount = 0 nodecount = 0
for label, nodes in sorted(pycompat.iteritems(self._entries)): for label, nodes in sorted(pycompat.iteritems(self._entries)):
label = encoding.fromlocal(label) label = encoding.fromlocal(label)
for node in nodes: for node in nodes:
nodecount += 1 nodecount += 1
if node in self._closednodes: if node in self._closednodes:
state = b'c' state = b'c'
else: else:
state = b'o' state = b'o'
f.write(b"%s %s %s\n" % (hex(node), state, label)) f.write(b"%s %s %s\n" % (hex(node), state, label))
f.close() f.close()
repo.ui.log( repo.ui.log(
b'branchcache', b'branchcache',
b'wrote %s with %d labels and %d nodes\n', b'wrote %s with %d labels and %d nodes\n',
_branchcachedesc(repo), _branchcachedesc(repo),
len(self._entries), len(self._entries),
nodecount, nodecount,
) )
self._delayed = False
except (IOError, OSError, error.Abort) as inst: except (IOError, OSError, error.Abort) as inst:
# Abort may be raised by read only opener, so log and continue # Abort may be raised by read only opener, so log and continue
repo.ui.debug( repo.ui.debug(
b"couldn't write branch cache: %s\n" b"couldn't write branch cache: %s\n"
% stringutil.forcebytestr(inst) % stringutil.forcebytestr(inst)
) )
def update(self, repo, revgen): def update(self, repo, revgen):

mercurial/localrepo.py

caches = repository.CACHES_DEFAULT caches = repository.CACHES_DEFAULT
if repository.CACHE_BRANCHMAP_SERVED in caches: if repository.CACHE_BRANCHMAP_SERVED in caches:
if tr is None or tr.changes[b'origrepolen'] < len(self): if tr is None or tr.changes[b'origrepolen'] < len(self):
# accessing the 'served' branchmap should refresh all the others, # accessing the 'served' branchmap should refresh all the others,
self.ui.debug(b'updating the branch cache\n') self.ui.debug(b'updating the branch cache\n')
self.filtered(b'served').branchmap() self.filtered(b'served').branchmap()
self.filtered(b'served.hidden').branchmap() self.filtered(b'served.hidden').branchmap()
# flush all possibly delayed write.
self._branchcaches.write_delayed(self)
if repository.CACHE_CHANGELOG_CACHE in caches: if repository.CACHE_CHANGELOG_CACHE in caches:
self.changelog.update_caches(transaction=tr) self.changelog.update_caches(transaction=tr)
if repository.CACHE_MANIFESTLOG_CACHE in caches: if repository.CACHE_MANIFESTLOG_CACHE in caches:
self.manifestlog.update_caches(transaction=tr) self.manifestlog.update_caches(transaction=tr)
if repository.CACHE_REV_BRANCH in caches: if repository.CACHE_REV_BRANCH in caches:

tests/test-branches.t

adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
transaction abort! transaction abort!
rollback completed rollback completed
abort: pretxnclose hook failed abort: pretxnclose hook failed
[40] [40]
$ cat branchmap-update-02/.hg/cache/branch2-served $ cat branchmap-update-02/.hg/cache/branch2-served
99ba08759bc7f6fdbe5304e83d0387f35c082479 1 (missing-correct-output !) 99ba08759bc7f6fdbe5304e83d0387f35c082479 1
99ba08759bc7f6fdbe5304e83d0387f35c082479 o A (missing-correct-output !) 99ba08759bc7f6fdbe5304e83d0387f35c082479 o A
71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 3 (known-bad-output !)
71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 o A (known-bad-output !)