← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/chk_map.py

Add a NEWS entry and prepare submission.

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):
692
671
        the key/value pairs.
693
672
    """
694
673
 
695
 
    __slots__ = ('_common_serialised_prefix',)
 
674
    __slots__ = ('_common_serialised_prefix', '_serialise_key')
696
675
 
697
676
    def __init__(self, search_key_func=None):
698
677
        Node.__init__(self)
699
678
        # All of the keys in this leaf node share this common prefix
700
679
        self._common_serialised_prefix = None
 
680
        self._serialise_key = '\x00'.join
701
681
        if search_key_func is None:
702
682
            self._search_key_func = _search_key_plain
703
683
        else:
887
867
                raise AssertionError('%r must be known' % self._search_prefix)
888
868
            return self._search_prefix, [("", self)]
889
869
 
890
 
    _serialise_key = '\x00'.join
891
 
 
892
870
    def serialise(self, store):
893
871
        """Serialise the LeafNode to store.
894
872
 
923
901
        bytes = ''.join(lines)
924
902
        if len(bytes) != self._current_size():
925
903
            raise AssertionError('Invalid _current_size')
926
 
        _get_cache().add(self._key, bytes)
 
904
        _page_cache.add(self._key, bytes)
927
905
        return [self._key]
928
906
 
929
907
    def refs(self):
1165
1143
            found_keys = set()
1166
1144
            for key in keys:
1167
1145
                try:
1168
 
                    bytes = _get_cache()[key]
 
1146
                    bytes = _page_cache[key]
1169
1147
                except KeyError:
1170
1148
                    continue
1171
1149
                else:
1196
1174
                    prefix, node_key_filter = keys[record.key]
1197
1175
                    node_and_filters.append((node, node_key_filter))
1198
1176
                    self._items[prefix] = node
1199
 
                    _get_cache().add(record.key, bytes)
 
1177
                    _page_cache.add(record.key, bytes)
1200
1178
                for info in node_and_filters:
1201
1179
                    yield info
1202
1180
 
1322
1300
            lines.append(serialised[prefix_len:])
1323
1301
        sha1, _, _ = store.add_lines((None,), (), lines)
1324
1302
        self._key = StaticTuple("sha1:" + sha1,).intern()
1325
 
        _get_cache().add(self._key, ''.join(lines))
 
1303
        _page_cache.add(self._key, ''.join(lines))
1326
1304
        yield self._key
1327
1305
 
1328
1306
    def _search_key(self, key):
1511
1489
        self._state = None
1512
1490
 
1513
1491
    def _read_nodes_from_store(self, keys):
1514
 
        # We chose not to use _get_cache(), because we think in
1515
 
        # terms of records to be yielded. Also, we expect to touch each page
1516
 
        # only 1 time during this code. (We may want to evaluate saving the
1517
 
        # raw bytes into the page cache, which would allow a working tree
1518
 
        # 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.)
1519
1497
        as_st = StaticTuple.from_sequence
1520
1498
        stream = self._store.get_record_stream(keys, 'unordered', True)
1521
1499
        for record in stream: