/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/chk_map.py

  • Committer: Jelmer Vernooij
  • Date: 2009-10-27 21:54:26 UTC
  • mfrom: (4771 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4833.
  • Revision ID: jelmer@samba.org-20091027215426-72164bkd4mq9dsd4
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(), """
51
50
    lru_cache,
52
51
    osutils,
53
52
    registry,
54
 
    static_tuple,
55
53
    trace,
56
54
    )
57
55
from bzrlib.static_tuple import StaticTuple
60
58
# If each line is 50 bytes, and you have 255 internal pages, with 255-way fan
61
59
# out, it takes 3.1MB to cache the layer.
62
60
_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
 
 
 
61
# We are caching bytes so len(value) is perfectly accurate
 
62
_page_cache = lru_cache.LRUSizeCache(_PAGE_CACHE_SIZE)
84
63
 
85
64
def clear_cache():
86
 
    _get_cache().clear()
87
 
 
 
65
    _page_cache.clear()
88
66
 
89
67
# If a ChildNode falls below this many bytes, we check for a remap
90
68
_INTERESTING_NEW_SIZE = 50
182
160
 
183
161
    def _read_bytes(self, key):
184
162
        try:
185
 
            return _get_cache()[key]
 
163
            return _page_cache[key]
186
164
        except KeyError:
187
165
            stream = self._store.get_record_stream([key], 'unordered', True)
188
166
            bytes = stream.next().get_bytes_as('fulltext')
189
 
            _get_cache()[key] = bytes
 
167
            _page_cache[key] = bytes
190
168
            return bytes
191
169
 
192
170
    def _dump_tree(self, include_keys=False):
692
670
        the key/value pairs.
693
671
    """
694
672
 
695
 
    __slots__ = ('_common_serialised_prefix',)
 
673
    __slots__ = ('_common_serialised_prefix', '_serialise_key')
696
674
 
697
675
    def __init__(self, search_key_func=None):
698
676
        Node.__init__(self)
699
677
        # All of the keys in this leaf node share this common prefix
700
678
        self._common_serialised_prefix = None
 
679
        self._serialise_key = '\x00'.join
701
680
        if search_key_func is None:
702
681
            self._search_key_func = _search_key_plain
703
682
        else:
741
720
        :param bytes: The bytes of the node.
742
721
        :param key: The key that the serialised node has.
743
722
        """
744
 
        key = static_tuple.expect_static_tuple(key)
745
723
        return _deserialise_leaf_node(bytes, key,
746
724
                                      search_key_func=search_key_func)
747
725
 
887
865
                raise AssertionError('%r must be known' % self._search_prefix)
888
866
            return self._search_prefix, [("", self)]
889
867
 
890
 
    _serialise_key = '\x00'.join
891
 
 
892
868
    def serialise(self, store):
893
869
        """Serialise the LeafNode to store.
894
870
 
923
899
        bytes = ''.join(lines)
924
900
        if len(bytes) != self._current_size():
925
901
            raise AssertionError('Invalid _current_size')
926
 
        _get_cache().add(self._key, bytes)
 
902
        _page_cache.add(self._key, bytes)
927
903
        return [self._key]
928
904
 
929
905
    def refs(self):
1042
1018
        :param key: The key that the serialised node has.
1043
1019
        :return: An InternalNode instance.
1044
1020
        """
1045
 
        key = static_tuple.expect_static_tuple(key)
 
1021
        if type(key) is not StaticTuple:
 
1022
            raise AssertionError('deserialise should be called with a'
 
1023
                                 ' StaticTuple not %s' % (type(key),))
1046
1024
        return _deserialise_internal_node(bytes, key,
1047
1025
                                          search_key_func=search_key_func)
1048
1026
 
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: