← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/chk_map.py

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/chk_map.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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: