/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/graph.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-03-24 23:19:12 UTC
  • mfrom: (4190.1.6 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090324231912-rb0kgktzkvge8aea
(robertc) Negatively cache ghosts and misses during read-locks in
        RemoteRepository. (Robert Collins, Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/graph.py
121
121
            self._get_parent_map = self._real_provider.get_parent_map
122
122
        else:
123
123
            self._get_parent_map = get_parent_map
124
 
        self._cache = {}
125
 
        self._cache_misses = True
 
124
        self._cache = None
 
125
        self.enable_cache(True)
126
126
 
127
127
    def __repr__(self):
128
128
        return "%s(%r)" % (self.__class__.__name__, self._real_provider)
133
133
            raise AssertionError('Cache enabled when already enabled.')
134
134
        self._cache = {}
135
135
        self._cache_misses = cache_misses
 
136
        self.missing_keys = set()
136
137
 
137
138
    def disable_cache(self):
138
139
        """Disable and clear the cache."""
139
140
        self._cache = None
 
141
        self._cache_misses = None
 
142
        self.missing_keys = set()
140
143
 
141
144
    def get_cached_map(self):
142
145
        """Return any cached get_parent_map values."""
143
146
        if self._cache is None:
144
147
            return None
145
 
        return dict((k, v) for k, v in self._cache.items()
146
 
                    if v is not None)
 
148
        return dict(self._cache)
147
149
 
148
150
    def get_parent_map(self, keys):
149
151
        """See _StackedParentsProvider.get_parent_map."""
150
 
        # Hack to build up the caching logic.
151
 
        ancestry = self._cache
152
 
        if ancestry is None:
153
 
            # Caching is disabled.
154
 
            missing_revisions = set(keys)
155
 
            ancestry = {}
 
152
        cache = self._cache
 
153
        if cache is None:
 
154
            cache = self._get_parent_map(keys)
156
155
        else:
157
 
            missing_revisions = set(key for key in keys if key not in ancestry)
158
 
        if missing_revisions:
159
 
            parent_map = self._get_parent_map(missing_revisions)
160
 
            ancestry.update(parent_map)
161
 
            if self._cache_misses:
162
 
                # None is never a valid parents list, so it can be used to
163
 
                # record misses.
164
 
                ancestry.update(dict((k, None) for k in missing_revisions
165
 
                                     if k not in parent_map))
166
 
        present_keys = [k for k in keys if ancestry.get(k) is not None]
167
 
        return dict((k, ancestry[k]) for k in present_keys)
 
156
            needed_revisions = set(key for key in keys if key not in cache)
 
157
            # Do not ask for negatively cached keys
 
158
            needed_revisions.difference_update(self.missing_keys)
 
159
            if needed_revisions:
 
160
                parent_map = self._get_parent_map(needed_revisions)
 
161
                cache.update(parent_map)
 
162
                if self._cache_misses:
 
163
                    for key in needed_revisions:
 
164
                        if key not in parent_map:
 
165
                            self.note_missing_key(key)
 
166
        result = {}
 
167
        for key in keys:
 
168
            value = cache.get(key)
 
169
            if value is not None:
 
170
                result[key] = value
 
171
        return result
 
172
 
 
173
    def note_missing_key(self, key):
 
174
        """Note that key is a missing key."""
 
175
        if self._cache_misses:
 
176
            self.missing_keys.add(key)
168
177
 
169
178
 
170
179
class Graph(object):