← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/groupcompress.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 06:45:57 UTC
  • mfrom: (5247.2.41 more-ignored-exceptions)
  • Revision ID: pqm@pqm.ubuntu.com-20100901064557-qsxmjmp195ozbluf
(vila) Catch EPIPE when shutting down test servers. (Vincent Ladeuil)

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."""
1629
1631
        keys_to_add = []
1630
1632
        def flush():
1631
1633
            bytes = self._compressor.flush().to_bytes()
 
1634
            self._compressor = GroupCompressor()
1632
1635
            index, start, length = self._access.add_raw_records(
1633
1636
                [(None, len(bytes))], bytes)[0]
1634
1637
            nodes = []
1637
1640
            self._index.add_records(nodes, random_id=random_id)
1638
1641
            self._unadded_refs = {}
1639
1642
            del keys_to_add[:]
1640
 
            self._compressor = GroupCompressor()
1641
1643
 
1642
1644
        last_prefix = None
1643
1645
        max_fulltext_len = 0
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
1802
1809
        return result
1803
1810
 
1804
1811
 
 
1812
class _GCBuildDetails(object):
 
1813
    """A blob of data about the build details.
 
1814
 
 
1815
    This stores the minimal data, which then allows compatibility with the old
 
1816
    api, without taking as much memory.
 
1817
    """
 
1818
 
 
1819
    __slots__ = ('_index', '_group_start', '_group_end', '_basis_end',
 
1820
                 '_delta_end', '_parents')
 
1821
 
 
1822
    method = 'group'
 
1823
    compression_parent = None
 
1824
 
 
1825
    def __init__(self, parents, position_info):
 
1826
        self._parents = parents
 
1827
        (self._index, self._group_start, self._group_end, self._basis_end,
 
1828
         self._delta_end) = position_info
 
1829
 
 
1830
    def __repr__(self):
 
1831
        return '%s(%s, %s)' % (self.__class__.__name__,
 
1832
            self.index_memo, self._parents)
 
1833
 
 
1834
    @property
 
1835
    def index_memo(self):
 
1836
        return (self._index, self._group_start, self._group_end,
 
1837
                self._basis_end, self._delta_end)
 
1838
 
 
1839
    @property
 
1840
    def record_details(self):
 
1841
        return static_tuple.StaticTuple(self.method, None)
 
1842
 
 
1843
    def __getitem__(self, offset):
 
1844
        """Compatibility thunk to act like a tuple."""
 
1845
        if offset == 0:
 
1846
            return self.index_memo
 
1847
        elif offset == 1:
 
1848
            return self.compression_parent # Always None
 
1849
        elif offset == 2:
 
1850
            return self._parents
 
1851
        elif offset == 3:
 
1852
            return self.record_details
 
1853
        else:
 
1854
            raise IndexError('offset out of range')
 
1855
            
 
1856
    def __len__(self):
 
1857
        return 4
 
1858
 
 
1859
 
1805
1860
class _GCGraphIndex(object):
1806
1861
    """Mapper from GroupCompressVersionedFiles needs into GraphIndex storage."""
1807
1862
 
1832
1887
        self.has_graph = parents
1833
1888
        self._is_locked = is_locked
1834
1889
        self._inconsistency_fatal = inconsistency_fatal
 
1890
        # GroupCompress records tend to have the same 'group' start + offset
 
1891
        # repeated over and over, this creates a surplus of ints
 
1892
        self._int_cache = {}
1835
1893
        if track_external_parent_refs:
1836
1894
            self._key_dependencies = knit._KeyRefs(
1837
1895
                track_new_keys=track_new_keys)
1873
1931
        if not random_id:
1874
1932
            present_nodes = self._get_entries(keys)
1875
1933
            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])
 
1934
                # Sometimes these are passed as a list rather than a tuple
 
1935
                node_refs = static_tuple.as_tuples(node_refs)
 
1936
                passed = static_tuple.as_tuples(keys[key])
 
1937
                if node_refs != passed[1]:
 
1938
                    details = '%s %s %s' % (key, (value, node_refs), passed)
1878
1939
                    if self._inconsistency_fatal:
1879
1940
                        raise errors.KnitCorrupt(self, "inconsistent details"
1880
1941
                                                 " in add_records: %s" %
1996
2057
                parents = None
1997
2058
            else:
1998
2059
                parents = entry[3][0]
1999
 
            method = 'group'
2000
 
            result[key] = (self._node_to_position(entry),
2001
 
                                  None, parents, (method, None))
 
2060
            details = _GCBuildDetails(parents, self._node_to_position(entry))
 
2061
            result[key] = details
2002
2062
        return result
2003
2063
 
2004
2064
    def keys(self):
2013
2073
        """Convert an index value to position details."""
2014
2074
        bits = node[2].split(' ')
2015
2075
        # It would be nice not to read the entire gzip.
 
2076
        # start and stop are put into _int_cache because they are very common.
 
2077
        # They define the 'group' that an entry is in, and many groups can have
 
2078
        # thousands of objects.
 
2079
        # Branching Launchpad, for example, saves ~600k integers, at 12 bytes
 
2080
        # each, or about 7MB. Note that it might be even more when you consider
 
2081
        # how PyInt is allocated in separate slabs. And you can't return a slab
 
2082
        # to the OS if even 1 int on it is in use. Note though that Python uses
 
2083
        # a LIFO when re-using PyInt slots, which might cause more
 
2084
        # fragmentation.
2016
2085
        start = int(bits[0])
 
2086
        start = self._int_cache.setdefault(start, start)
2017
2087
        stop = int(bits[1])
 
2088
        stop = self._int_cache.setdefault(stop, stop)
2018
2089
        basis_end = int(bits[2])
2019
2090
        delta_end = int(bits[3])
2020
 
        return node[0], start, stop, basis_end, delta_end
 
2091
        # We can't use StaticTuple here, because node[0] is a BTreeGraphIndex
 
2092
        # instance...
 
2093
        return (node[0], start, stop, basis_end, delta_end)
2021
2094
 
2022
2095
    def scan_unvalidated_index(self, graph_index):
2023
2096
        """Inform this _GCGraphIndex that there is an unvalidated index.