← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/chk_map.py

  • Committer: Martin Pool
  • Date: 2010-01-15 05:33:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5019.
  • Revision ID: mbp@sourcefrog.net-20100115053328-z8lykwv6zmkmkp9p
Further progress bar string-pulling

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/chk_map.py
38
38
"""
39
39
 
40
40
import heapq
41
 
import threading
42
41
 
43
42
from bzrlib import lazy_import
44
43
lazy_import.lazy_import(globals(), """
60
59
# If each line is 50 bytes, and you have 255 internal pages, with 255-way fan
61
60
# out, it takes 3.1MB to cache the layer.
62
61
_PAGE_CACHE_SIZE = 4*1024*1024
63
 
# Per thread caches for 2 reasons:
64
 
# - in the server we may be serving very different content, so we get less
65
 
#   cache thrashing.
66
 
# - we avoid locking on every cache lookup.
67
 
_thread_caches = threading.local()
68
 
# The page cache.
69
 
_thread_caches.page_cache = None
70
 
 
71
 
def _get_cache():
72
 
    """Get the per-thread page cache.
73
 
 
74
 
    We need a function to do this because in a new thread the _thread_caches
75
 
    threading.local object does not have the cache initialized yet.
76
 
    """
77
 
    page_cache = getattr(_thread_caches, 'page_cache', None)
78
 
    if page_cache is None:
79
 
        # We are caching bytes so len(value) is perfectly accurate
80
 
        page_cache = lru_cache.LRUSizeCache(_PAGE_CACHE_SIZE)
81
 
        _thread_caches.page_cache = page_cache
82
 
    return page_cache
83
 
 
 
62
# We are caching bytes so len(value) is perfectly accurate
 
63
_page_cache = lru_cache.LRUSizeCache(_PAGE_CACHE_SIZE)
84
64
 
85
65
def clear_cache():
86
 
    _get_cache().clear()
87
 
 
 
66
    _page_cache.clear()
88
67
 
89
68
# If a ChildNode falls below this many bytes, we check for a remap
90
69
_INTERESTING_NEW_SIZE = 50
182
161
 
183
162
    def _read_bytes(self, key):
184
163
        try:
185
 
            return _get_cache()[key]
 
164
            return _page_cache[key]
186
165
        except KeyError:
187
166
            stream = self._store.get_record_stream([key], 'unordered', True)
188
167
            bytes = stream.next().get_bytes_as('fulltext')
189
 
            _get_cache()[key] = bytes
 
168
            _page_cache[key] = bytes
190
169
            return bytes
191
170
 
192
171
    def _dump_tree(self, include_keys=False):
922
901
        bytes = ''.join(lines)
923
902
        if len(bytes) != self._current_size():
924
903
            raise AssertionError('Invalid _current_size')
925
 
        _get_cache().add(self._key, bytes)
 
904
        _page_cache.add(self._key, bytes)
926
905
        return [self._key]
927
906
 
928
907
    def refs(self):
1164
1143
            found_keys = set()
1165
1144
            for key in keys:
1166
1145
                try:
1167
 
                    bytes = _get_cache()[key]
 
1146
                    bytes = _page_cache[key]
1168
1147
                except KeyError:
1169
1148
                    continue
1170
1149
                else:
1195
1174
                    prefix, node_key_filter = keys[record.key]
1196
1175
                    node_and_filters.append((node, node_key_filter))
1197
1176
                    self._items[prefix] = node
1198
 
                    _get_cache().add(record.key, bytes)
 
1177
                    _page_cache.add(record.key, bytes)
1199
1178
                for info in node_and_filters:
1200
1179
                    yield info
1201
1180
 
1321
1300
            lines.append(serialised[prefix_len:])
1322
1301
        sha1, _, _ = store.add_lines((None,), (), lines)
1323
1302
        self._key = StaticTuple("sha1:" + sha1,).intern()
1324
 
        _get_cache().add(self._key, ''.join(lines))
 
1303
        _page_cache.add(self._key, ''.join(lines))
1325
1304
        yield self._key
1326
1305
 
1327
1306
    def _search_key(self, key):
1510
1489
        self._state = None
1511
1490
 
1512
1491
    def _read_nodes_from_store(self, keys):
1513
 
        # We chose not to use _get_cache(), because we think in
1514
 
        # terms of records to be yielded. Also, we expect to touch each page
1515
 
        # only 1 time during this code. (We may want to evaluate saving the
1516
 
        # raw bytes into the page cache, which would allow a working tree
1517
 
        # update after the fetch to not have to read the bytes again.)
 
1492
        # We chose not to use _page_cache, because we think in terms of records
 
1493
        # to be yielded. Also, we expect to touch each page only 1 time during
 
1494
        # this code. (We may want to evaluate saving the raw bytes into the
 
1495
        # page cache, which would allow a working tree update after the fetch
 
1496
        # to not have to read the bytes again.)
1518
1497
        as_st = StaticTuple.from_sequence
1519
1498
        stream = self._store.get_record_stream(keys, 'unordered', True)
1520
1499
        for record in stream: