This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4500

util: ability to change capacity when copying lrucachedict
ClosedPublic

Authored by indygreg on Sep 6 2018, 9:17 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG2dcc68c7d25b: util: ability to change capacity when copying lrucachedict
Summary

This will allow us to easily replace an lrucachedict with one
with a higher or lower capacity as consumers deem necessary.

IMO it is easier to just create a new cache instance than to
muck with the capacity of an existing cache. Mutating an existing
cache's capacity feels more prone to bugs.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Sep 6 2018, 9:17 PM
Closed by commit rHG2dcc68c7d25b: util: ability to change capacity when copying lrucachedict (authored by indygreg). · Explain WhySep 12 2018, 10:52 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/util.py (17 lines)
Mtests/test-lrucachedict.py (54 lines)

Diff 10819

mercurial/util.py

def clear(self): def clear(self):
n = self._head n = self._head
while n.key is not _notset: while n.key is not _notset:
n.markempty() n.markempty()
n = n.next n = n.next
self._cache.clear() self._cache.clear()
def copy(self): def copy(self, capacity=None):
result = lrucachedict(self.capacity) """Create a new cache as a copy of the current one.
By default, the new cache has the same capacity as the existing one.
But, the cache capacity can be changed as part of performing the
copy.
Items in the copy have an insertion/access order matching this
instance.
"""
capacity = capacity or self.capacity
result = lrucachedict(capacity)
# We copy entries by iterating in oldest-to-newest order so the copy # We copy entries by iterating in oldest-to-newest order so the copy
# has the correct ordering. # has the correct ordering.
# Find the first non-empty entry. # Find the first non-empty entry.
n = self._head.prev n = self._head.prev
while n.key is _notset and n is not self._head: while n.key is _notset and n is not self._head:
n = n.prev n = n.prev
# We could potentially skip the first N items when decreasing capacity.
# But let's keep it simple unless it is a performance problem.
for i in range(len(self._cache)): for i in range(len(self._cache)):
result[n.key] = n.value result[n.key] = n.value
n = n.prev n = n.prev
return result return result
def _movetohead(self, node): def _movetohead(self, node):
"""Mark a node as the newest, making it the new head. """Mark a node as the newest, making it the new head.

tests/test-lrucachedict.py

# Contents and order of original dict should remain unchanged. # Contents and order of original dict should remain unchanged.
dc['b'] = 'vb_new' dc['b'] = 'vb_new'
self.assertEqual(list(iter(d)), ['d', 'c', 'b', 'a']) self.assertEqual(list(iter(d)), ['d', 'c', 'b', 'a'])
for key in ('a', 'b', 'c', 'd'): for key in ('a', 'b', 'c', 'd'):
self.assertEqual(d[key], 'v%s' % key) self.assertEqual(d[key], 'v%s' % key)
def testcopydecreasecapacity(self):
d = util.lrucachedict(5)
d['a'] = 'va'
d['b'] = 'vb'
d['c'] = 'vc'
d['d'] = 'vd'
dc = d.copy(2)
for key in ('a', 'b'):
self.assertNotIn(key, dc)
for key in ('c', 'd'):
self.assertIn(key, dc)
self.assertEqual(dc[key], 'v%s' % key)
dc['e'] = 've'
self.assertNotIn('c', dc)
for key in ('d', 'e'):
self.assertIn(key, dc)
self.assertEqual(dc[key], 'v%s' % key)
# Original should remain unchanged.
for key in ('a', 'b', 'c', 'd'):
self.assertIn(key, d)
self.assertEqual(d[key], 'v%s' % key)
def testcopyincreasecapacity(self):
d = util.lrucachedict(5)
d['a'] = 'va'
d['b'] = 'vb'
d['c'] = 'vc'
d['d'] = 'vd'
dc = d.copy(6)
for key in ('a', 'b', 'c', 'd'):
self.assertIn(key, dc)
self.assertEqual(dc[key], 'v%s' % key)
dc['e'] = 've'
dc['f'] = 'vf'
for key in ('a', 'b', 'c', 'd', 'e', 'f'):
self.assertIn(key, dc)
self.assertEqual(dc[key], 'v%s' % key)
dc['g'] = 'vg'
self.assertNotIn('a', dc)
for key in ('b', 'c', 'd', 'e', 'f', 'g'):
self.assertIn(key, dc)
self.assertEqual(dc[key], 'v%s' % key)
# Original should remain unchanged.
for key in ('a', 'b', 'c', 'd'):
self.assertIn(key, d)
self.assertEqual(d[key], 'v%s' % key)
if __name__ == '__main__': if __name__ == '__main__':
silenttestrunner.main(__name__) silenttestrunner.main(__name__)