caches: introduce a function to warm cache

We have multiple caches that gain from being kept up to date. For example in a
server setup, we want to make sure the branchcache cache is hot for other
read-only clients.

Right now each cache tries to update themself in place where new data have been
added. However the approach is error prone (we might miss some spot) and
fragile. When nested transaction are involved, such cache updates might happen
before a top level transaction is committed. Writing caches for uncommitted
data on disk.

Having a single entry point, run at the end of each successful transaction,
helps to ensure the cache is up to date and refreshed at the right time.

We start with updating the branchmap cache but other will come.

mercurial/localrepo.py

@@ -1093,6 +1093,10 b' class localrepository(object):'
                                **pycompat.strkwargs(hookargs))
             reporef()._afterlock(hook)
         tr.addfinalize('txnclose-hook', txnclosehook)
+        def warmscache(tr2):
+            repo = reporef()
+            repo.updatecaches(tr2)
+        tr.addpostclose('warms-cache', warmscache)
         def txnaborthook(tr2):
             """To be run if transaction is aborted
             """
@@ -1227,6 +1231,17 b' class localrepository(object):'
         self.destroyed()
         return 0
 
+    @unfilteredmethod
+    def updatecaches(self, tr):
+        """warm appropriate caches after a transaction closed"""
+        if tr.hookargs.get('source') == 'strip':
+            # During strip, many caches are invalid but
+            # later call to `destroyed` will refresh them.
+            return
+
+        if tr.changes['revs']:
+            branchmap.updatecache(self.filtered('served'))
+
     def invalidatecaches(self):
 
         if '_tagscache' in vars(self):