← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/groupcompress.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/groupcompress.py
1
 
# Copyright (C) 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2008, 2009, 2010 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
31
31
    knit,
32
32
    osutils,
33
33
    pack,
 
34
    static_tuple,
34
35
    trace,
35
36
    )
36
37
from bzrlib.btree_index import BTreeBuilder
1269
1270
        """See VersionedFiles.clear_cache()"""
1270
1271
        self._group_cache.clear()
1271
1272
        self._index._graph_index.clear_cache()
 
1273
        self._index._int_cache.clear()
1272
1274
 
1273
1275
    def _check_add(self, key, lines, random_id, check_content):
1274
1276
        """check that version_id and lines are safe to add."""
1745
1747
                key = record.key
1746
1748
            self._unadded_refs[key] = record.parents
1747
1749
            yield found_sha1
1748
 
            keys_to_add.append((key, '%d %d' % (start_point, end_point),
1749
 
                (record.parents,)))
 
1750
            as_st = static_tuple.StaticTuple.from_sequence
 
1751
            if record.parents is not None:
 
1752
                parents = as_st([as_st(p) for p in record.parents])
 
1753
            else:
 
1754
                parents = None
 
1755
            refs = static_tuple.StaticTuple(parents)
 
1756
            keys_to_add.append((key, '%d %d' % (start_point, end_point), refs))
1750
1757
        if len(keys_to_add):
1751
1758
            flush()
1752
1759
        self._compressor = None
1832
1839
        self.has_graph = parents
1833
1840
        self._is_locked = is_locked
1834
1841
        self._inconsistency_fatal = inconsistency_fatal
 
1842
        # GroupCompress records tend to have the same 'group' start + offset
 
1843
        # repeated over and over, this creates a surplus of ints
 
1844
        self._int_cache = {}
1835
1845
        if track_external_parent_refs:
1836
1846
            self._key_dependencies = knit._KeyRefs(
1837
1847
                track_new_keys=track_new_keys)
1873
1883
        if not random_id:
1874
1884
            present_nodes = self._get_entries(keys)
1875
1885
            for (index, key, value, node_refs) in present_nodes:
1876
 
                if node_refs != keys[key][1]:
1877
 
                    details = '%s %s %s' % (key, (value, node_refs), keys[key])
 
1886
                # Sometimes these are passed as a list rather than a tuple
 
1887
                node_refs = static_tuple.as_tuples(node_refs)
 
1888
                passed = static_tuple.as_tuples(keys[key])
 
1889
                if node_refs != passed[1]:
 
1890
                    details = '%s %s %s' % (key, (value, node_refs), passed)
1878
1891
                    if self._inconsistency_fatal:
1879
1892
                        raise errors.KnitCorrupt(self, "inconsistent details"
1880
1893
                                                 " in add_records: %s" %
2013
2026
        """Convert an index value to position details."""
2014
2027
        bits = node[2].split(' ')
2015
2028
        # It would be nice not to read the entire gzip.
 
2029
        # start and stop are put into _int_cache because they are very common.
 
2030
        # They define the 'group' that an entry is in, and many groups can have
 
2031
        # thousands of objects.
 
2032
        # Branching Launchpad, for example, saves ~600k integers, at 12 bytes
 
2033
        # each, or about 7MB. Note that it might be even more when you consider
 
2034
        # how PyInt is allocated in separate slabs. And you can't return a slab
 
2035
        # to the OS if even 1 int on it is in use. Note though that Python uses
 
2036
        # a LIFO when re-using PyInt slots, which probably causes more
 
2037
        # fragmentation.
2016
2038
        start = int(bits[0])
 
2039
        start = self._int_cache.setdefault(start, start)
2017
2040
        stop = int(bits[1])
 
2041
        stop = self._int_cache.setdefault(stop, stop)
2018
2042
        basis_end = int(bits[2])
2019
2043
        delta_end = int(bits[3])
2020
 
        return node[0], start, stop, basis_end, delta_end
 
2044
        # We can't use StaticTuple here, because node[0] is a BTreeGraphIndex
 
2045
        # instance...
 
2046
        return (node[0], start, stop, basis_end, delta_end)
2021
2047
 
2022
2048
    def scan_unvalidated_index(self, graph_index):
2023
2049
        """Inform this _GCGraphIndex that there is an unvalidated index.