Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revlog.py @ 51100:8ec2de9c6770

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
revlog: move the_revisioncache on the inner object The goal for this inner object is to compute that things we cache, it make more sense to have the inner object handle it directly.
author Pierre-Yves David <pierre-yves.david@octobus.net>
date Thu, 19 Oct 2023 03:33:59 +0200
parents 30f458fc59e9
children be56d322ee89
comparison
equal deleted inserted replaced
51099:30f458fc59e9 51100:8ec2de9c6770
388 self.data_config.chunk_cache_size, 388 self.data_config.chunk_cache_size,
389 ) 389 )
390 390
391 # revlog header -> revlog compressor 391 # revlog header -> revlog compressor
392 self._decompressors = {} 392 self._decompressors = {}
393 # 3-tuple of (node, rev, text) for a raw revision.
394 self._revisioncache = None
393 395
394 @property 396 @property
395 def index_file(self): 397 def index_file(self):
396 return self.__index_file 398 return self.__index_file
397 399
1021 self.delta_config = self.opener.options[b'delta-config'].copy() 1023 self.delta_config = self.opener.options[b'delta-config'].copy()
1022 else: 1024 else:
1023 self.delta_config = DeltaConfig() 1025 self.delta_config = DeltaConfig()
1024 self.delta_config.upper_bound_comp = upperboundcomp 1026 self.delta_config.upper_bound_comp = upperboundcomp
1025 1027
1026 # 3-tuple of (node, rev, text) for a raw revision.
1027 self._revisioncache = None
1028 # Maps rev to chain base rev. 1028 # Maps rev to chain base rev.
1029 self._chainbasecache = util.lrucachedict(100) 1029 self._chainbasecache = util.lrucachedict(100)
1030 1030
1031 self.index = None 1031 self.index = None
1032 self._docket = None 1032 self._docket = None
1663 else: 1663 else:
1664 nodemaputil.setup_persistent_nodemap(transaction, self) 1664 nodemaputil.setup_persistent_nodemap(transaction, self)
1665 1665
1666 def clearcaches(self): 1666 def clearcaches(self):
1667 """Clear in-memory caches""" 1667 """Clear in-memory caches"""
1668 self._revisioncache = None 1668 self._inner._revisioncache = None
1669 self._chainbasecache.clear() 1669 self._chainbasecache.clear()
1670 self._inner._segmentfile.clear_cache() 1670 self._inner._segmentfile.clear_cache()
1671 self._inner._segmentfile_sidedata.clear_cache() 1671 self._inner._segmentfile_sidedata.clear_cache()
1672 self._pcache = {} 1672 self._pcache = {}
1673 self._nodemap_docket = None 1673 self._nodemap_docket = None
2569 r = flagutil.processflagsread(self, rawtext, flags) 2569 r = flagutil.processflagsread(self, rawtext, flags)
2570 text, validatehash = r 2570 text, validatehash = r
2571 if validatehash: 2571 if validatehash:
2572 self.checkhash(text, node, rev=rev) 2572 self.checkhash(text, node, rev=rev)
2573 if not validated: 2573 if not validated:
2574 self._revisioncache = (node, rev, rawtext) 2574 self._inner._revisioncache = (node, rev, rawtext)
2575 2575
2576 return text 2576 return text
2577 2577
2578 def _rawtext(self, node, rev): 2578 def _rawtext(self, node, rev):
2579 """return the possibly unvalidated rawtext for a revision 2579 """return the possibly unvalidated rawtext for a revision
2586 # An intermediate text to apply deltas to 2586 # An intermediate text to apply deltas to
2587 basetext = None 2587 basetext = None
2588 2588
2589 # Check if we have the entry in cache 2589 # Check if we have the entry in cache
2590 # The cache entry looks like (node, rev, rawtext) 2590 # The cache entry looks like (node, rev, rawtext)
2591 if self._revisioncache: 2591 if self._inner._revisioncache:
2592 if self._revisioncache[0] == node: 2592 if self._inner._revisioncache[0] == node:
2593 return (rev, self._revisioncache[2], True) 2593 return (rev, self._inner._revisioncache[2], True)
2594 cachedrev = self._revisioncache[1] 2594 cachedrev = self._inner._revisioncache[1]
2595 2595
2596 if rev is None: 2596 if rev is None:
2597 rev = self.rev(node) 2597 rev = self.rev(node)
2598 2598
2599 chain, stopped = self._inner._deltachain(rev, stoprev=cachedrev) 2599 chain, stopped = self._inner._deltachain(rev, stoprev=cachedrev)
2600 if stopped: 2600 if stopped:
2601 basetext = self._revisioncache[2] 2601 basetext = self._inner._revisioncache[2]
2602 2602
2603 # drop cache to save memory, the caller is expected to 2603 # drop cache to save memory, the caller is expected to
2604 # update self._revisioncache after validating the text 2604 # update self._inner._revisioncache after validating the text
2605 self._revisioncache = None 2605 self._inner._revisioncache = None
2606 2606
2607 targetsize = None 2607 targetsize = None
2608 rawsize = self.index[rev][2] 2608 rawsize = self.index[rev][2]
2609 if 0 <= rawsize: 2609 if 0 <= rawsize:
2610 targetsize = 4 * rawsize 2610 targetsize = 4 * rawsize
2682 # only stores the raw revision and clearing the cache does have 2682 # only stores the raw revision and clearing the cache does have
2683 # the side-effect that we won't have a cache hit when the raw 2683 # the side-effect that we won't have a cache hit when the raw
2684 # revision data is accessed. But this case should be rare and 2684 # revision data is accessed. But this case should be rare and
2685 # it is extra work to teach the cache about the hash 2685 # it is extra work to teach the cache about the hash
2686 # verification state. 2686 # verification state.
2687 if self._revisioncache and self._revisioncache[0] == node: 2687 if (
2688 self._revisioncache = None 2688 self._inner._revisioncache
2689 and self._inner._revisioncache[0] == node
2690 ):
2691 self._inner._revisioncache = None
2689 2692
2690 revornode = rev 2693 revornode = rev
2691 if revornode is None: 2694 if revornode is None:
2692 revornode = templatefilters.short(hex(node)) 2695 revornode = templatefilters.short(hex(node))
2693 raise error.RevlogError( 2696 raise error.RevlogError(
3147 3150
3148 if alwayscache and rawtext is None: 3151 if alwayscache and rawtext is None:
3149 rawtext = deltacomputer.buildtext(revinfo) 3152 rawtext = deltacomputer.buildtext(revinfo)
3150 3153
3151 if type(rawtext) == bytes: # only accept immutable objects 3154 if type(rawtext) == bytes: # only accept immutable objects
3152 self._revisioncache = (node, curr, rawtext) 3155 self._inner._revisioncache = (node, curr, rawtext)
3153 self._chainbasecache[curr] = deltainfo.chainbase 3156 self._chainbasecache[curr] = deltainfo.chainbase
3154 return curr 3157 return curr
3155 3158
3156 def _get_data_offset(self, prev): 3159 def _get_data_offset(self, prev):
3157 """Returns the current offset in the (in-transaction) data file. 3160 """Returns the current offset in the (in-transaction) data file.
3430 self._docket.data_end = data_end 3433 self._docket.data_end = data_end
3431 self._docket.sidedata_end = sidedata_end 3434 self._docket.sidedata_end = sidedata_end
3432 self._docket.write(transaction, stripping=True) 3435 self._docket.write(transaction, stripping=True)
3433 3436
3434 # then reset internal state in memory to forget those revisions 3437 # then reset internal state in memory to forget those revisions
3435 self._revisioncache = None 3438 self._inner._revisioncache = None
3436 self._chaininfocache = util.lrucachedict(500) 3439 self._chaininfocache = util.lrucachedict(500)
3437 self._inner._segmentfile.clear_cache() 3440 self._inner._segmentfile.clear_cache()
3438 self._inner._segmentfile_sidedata.clear_cache() 3441 self._inner._segmentfile_sidedata.clear_cache()
3439 3442
3440 del self.index[rev:-1] 3443 del self.index[rev:-1]