← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tuned_gzip.py

(vila) Calling super() instead of mentioning the base class in setUp avoid
 mistakes. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tuned_gzip.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
# Written by Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
 
18
18
"""Bzrlib specific gzip tunings. We plan to feed these to the upstream gzip."""
19
19
 
 
20
from __future__ import absolute_import
 
21
 
 
22
from cStringIO import StringIO
 
23
 
20
24
# make GzipFile faster:
21
25
import gzip
22
 
from gzip import U32, LOWU32, FEXTRA, FCOMMENT, FNAME, FHCRC
 
26
from gzip import FEXTRA, FCOMMENT, FNAME, FHCRC
23
27
import sys
24
28
import struct
25
29
import zlib
26
30
 
27
 
__all__ = ["GzipFile"]
 
31
# we want a \n preserved, break on \n only splitlines.
 
32
from bzrlib import symbol_versioning
 
33
 
 
34
__all__ = ["GzipFile", "bytes_to_gzip"]
 
35
 
 
36
 
 
37
def U32(i):
 
38
    """Return i as an unsigned integer, assuming it fits in 32 bits.
 
39
 
 
40
    If it's >= 2GB when viewed as a 32-bit unsigned int, return a long.
 
41
    """
 
42
    if i < 0:
 
43
        i += 1L << 32
 
44
    return i
 
45
 
 
46
 
 
47
def LOWU32(i):
 
48
    """Return the low-order 32 bits of an int, as a non-negative int."""
 
49
    return i & 0xFFFFFFFFL
 
50
 
 
51
 
 
52
def bytes_to_gzip(bytes, factory=zlib.compressobj,
 
53
    level=zlib.Z_DEFAULT_COMPRESSION, method=zlib.DEFLATED,
 
54
    width=-zlib.MAX_WBITS, mem=zlib.DEF_MEM_LEVEL,
 
55
    crc32=zlib.crc32):
 
56
    """Create a gzip file containing bytes and return its content."""
 
57
    return chunks_to_gzip([bytes])
 
58
 
 
59
 
 
60
def chunks_to_gzip(chunks, factory=zlib.compressobj,
 
61
    level=zlib.Z_DEFAULT_COMPRESSION, method=zlib.DEFLATED,
 
62
    width=-zlib.MAX_WBITS, mem=zlib.DEF_MEM_LEVEL,
 
63
    crc32=zlib.crc32):
 
64
    """Create a gzip file containing chunks and return its content.
 
65
 
 
66
    :param chunks: An iterable of strings. Each string can have arbitrary
 
67
        layout.
 
68
    """
 
69
    result = [
 
70
        '\037\213'  # self.fileobj.write('\037\213')  # magic header
 
71
        '\010'      # self.fileobj.write('\010')      # compression method
 
72
                    # fname = self.filename[:-3]
 
73
                    # flags = 0
 
74
                    # if fname:
 
75
                    #     flags = FNAME
 
76
        '\x00'      # self.fileobj.write(chr(flags))
 
77
        '\0\0\0\0'  # write32u(self.fileobj, long(time.time()))
 
78
        '\002'      # self.fileobj.write('\002')
 
79
        '\377'      # self.fileobj.write('\377')
 
80
                    # if fname:
 
81
        ''          #     self.fileobj.write(fname + '\000')
 
82
        ]
 
83
    # using a compressobj avoids a small header and trailer that the compress()
 
84
    # utility function adds.
 
85
    compress = factory(level, method, width, mem, 0)
 
86
    crc = 0
 
87
    total_len = 0
 
88
    for chunk in chunks:
 
89
        crc = crc32(chunk, crc)
 
90
        total_len += len(chunk)
 
91
        zbytes = compress.compress(chunk)
 
92
        if zbytes:
 
93
            result.append(zbytes)
 
94
    result.append(compress.flush())
 
95
    # size may exceed 2GB, or even 4GB
 
96
    result.append(struct.pack("<LL", LOWU32(crc), LOWU32(total_len)))
 
97
    return ''.join(result)
28
98
 
29
99
 
30
100
class GzipFile(gzip.GzipFile):
50
120
    Yes, its only 1.6 seconds, but they add up.
51
121
    """
52
122
 
 
123
    def __init__(self, *args, **kwargs):
 
124
        symbol_versioning.warn(
 
125
            symbol_versioning.deprecated_in((2, 3, 0))
 
126
            % 'bzrlib.tuned_gzip.GzipFile',
 
127
            DeprecationWarning, stacklevel=2)
 
128
        gzip.GzipFile.__init__(self, *args, **kwargs)
 
129
 
53
130
    def _add_read_data(self, data):
54
131
        # 4169 calls in 183
55
132
        # temp var for len(data) and switch to +='s.
60
137
        self.extrasize += len_data
61
138
        self.size += len_data
62
139
 
 
140
    def _write_gzip_header(self):
 
141
        """A tuned version of gzip._write_gzip_header
 
142
 
 
143
        We have some extra constrains that plain Gzip does not.
 
144
        1) We want to write the whole blob at once. rather than multiple
 
145
           calls to fileobj.write().
 
146
        2) We never have a filename
 
147
        3) We don't care about the time
 
148
        """
 
149
        self.fileobj.write(
 
150
           '\037\213'   # self.fileobj.write('\037\213')  # magic header
 
151
            '\010'      # self.fileobj.write('\010')      # compression method
 
152
                        # fname = self.filename[:-3]
 
153
                        # flags = 0
 
154
                        # if fname:
 
155
                        #     flags = FNAME
 
156
            '\x00'      # self.fileobj.write(chr(flags))
 
157
            '\0\0\0\0'  # write32u(self.fileobj, long(time.time()))
 
158
            '\002'      # self.fileobj.write('\002')
 
159
            '\377'      # self.fileobj.write('\377')
 
160
                        # if fname:
 
161
            ''          #     self.fileobj.write(fname + '\000')
 
162
            )
 
163
 
63
164
    def _read(self, size=1024):
64
165
        # various optimisations:
65
 
        # reduces lsprof count from 2500 to 
 
166
        # reduces lsprof count from 2500 to
66
167
        # 8337 calls in 1272, 365 internal
67
168
        if self.fileobj is None:
68
169
            raise EOFError, "Reached EOF"
90
191
 
91
192
        if buf == "":
92
193
            self._add_read_data(self.decompress.flush())
93
 
            assert len(self.decompress.unused_data) >= 8, "what does flush do?"
 
194
            if len(self.decompress.unused_data) < 8:
 
195
                raise AssertionError("what does flush do?")
 
196
            self._gzip_tail = self.decompress.unused_data[0:8]
94
197
            self._read_eof()
95
198
            # tell the driving read() call we have stuffed all the data
96
199
            # in self.extrabuf
109
212
            # (The number of bytes to seek back is the length of the unused
110
213
            # data, minus 8 because those 8 bytes are part of this member.
111
214
            seek_length = len (self.decompress.unused_data) - 8
112
 
            if seek_length:
113
 
                assert seek_length > 0
 
215
            if seek_length > 0:
 
216
                # we read too much data
114
217
                self.fileobj.seek(-seek_length, 1)
 
218
                self._gzip_tail = self.decompress.unused_data[0:8]
 
219
            elif seek_length < 0:
 
220
                # we haven't read enough to check the checksum.
 
221
                if not (-8 < seek_length):
 
222
                    raise AssertionError("too great a seek")
 
223
                buf = self.fileobj.read(-seek_length)
 
224
                self._gzip_tail = self.decompress.unused_data + buf
 
225
            else:
 
226
                self._gzip_tail = self.decompress.unused_data
115
227
 
116
228
            # Check the CRC and file size, and set the flag so we read
117
229
            # a new member on the next call
122
234
        """tuned to reduce function calls and eliminate file seeking:
123
235
        pass 1:
124
236
        reduces lsprof count from 800 to 288
125
 
        4168 in 296 
 
237
        4168 in 296
126
238
        avoid U32 call by using struct format L
127
239
        4168 in 200
128
240
        """
129
 
        # We've read to the end of the file, so we should have 8 bytes of 
130
 
        # unused data in the decompressor. If we dont, there is a corrupt file.
 
241
        # We've read to the end of the file, so we should have 8 bytes of
 
242
        # unused data in the decompressor. If we don't, there is a corrupt file.
131
243
        # We use these 8 bytes to calculate the CRC and the recorded file size.
132
244
        # We then check the that the computed CRC and size of the
133
245
        # uncompressed data matches the stored values.  Note that the size
134
246
        # stored is the true file size mod 2**32.
135
 
        crc32, isize = struct.unpack("<LL", self.decompress.unused_data[0:8])
 
247
        if not (len(self._gzip_tail) == 8):
 
248
            raise AssertionError("gzip trailer is incorrect length.")
 
249
        crc32, isize = struct.unpack("<LL", self._gzip_tail)
136
250
        # note that isize is unsigned - it can exceed 2GB
137
251
        if crc32 != U32(self.crc):
138
 
            raise IOError, "CRC check failed"
 
252
            raise IOError, "CRC check failed %d %d" % (crc32, U32(self.crc))
139
253
        elif isize != LOWU32(self.size):
140
254
            raise IOError, "Incorrect length of data produced"
141
255
 
142
256
    def _read_gzip_header(self, bytes=None):
143
257
        """Supply bytes if the minimum header size is already read.
144
 
        
 
258
 
145
259
        :param bytes: 10 bytes of header data.
146
260
        """
147
261
        """starting cost: 300 in 3998
184
298
 
185
299
    def readline(self, size=-1):
186
300
        """Tuned to remove buffer length calls in _unread and...
187
 
        
 
301
 
188
302
        also removes multiple len(c) calls, inlines _unread,
189
303
        total savings - lsprof 5800 to 5300
190
304
        phase 2:
194
308
        leading to a drop to:
195
309
        4168 calls in 1977
196
310
        4168 call to read() in 1646
197
 
        - i.e. just reduced the function call overhead. May be worth 
 
311
        - i.e. just reduced the function call overhead. May be worth
198
312
          keeping.
199
313
        """
200
314
        if size < 0: size = sys.maxint
242
356
        # to :
243
357
        # 4168 calls in 417.
244
358
        # Negative numbers result in reading all the lines
245
 
        if sizehint <= 0:
246
 
            sizehint = -1
247
 
        content = self.read(sizehint)
248
 
        return content.splitlines(True)
 
359
 
 
360
        # python's gzip routine uses sizehint. This is a more efficient way
 
361
        # than python uses to honor it. But it is even more efficient to
 
362
        # just read the entire thing and use cStringIO to split into lines.
 
363
        # if sizehint <= 0:
 
364
        #     sizehint = -1
 
365
        # content = self.read(sizehint)
 
366
        # return bzrlib.osutils.split_lines(content)
 
367
        content = StringIO(self.read(-1))
 
368
        return content.readlines()
249
369
 
250
370
    def _unread(self, buf, len_buf=None):
251
371
        """tuned to remove unneeded len calls.
252
 
        
 
372
 
253
373
        because this is such an inner routine in readline, and readline is
254
374
        in many inner loops, this has been inlined into readline().
255
375
 
256
376
        The len_buf parameter combined with the reduction in len calls dropped
257
 
        the lsprof ms count for this routine on my test data from 800 to 200 - 
 
377
        the lsprof ms count for this routine on my test data from 800 to 200 -
258
378
        a 75% saving.
259
379
        """
260
380
        if len_buf is None:
278
398
            self.offset += data_len
279
399
 
280
400
    def writelines(self, lines):
281
 
        # profiling indicated a significant overhead 
 
401
        # profiling indicated a significant overhead
282
402
        # calling write for each line.
283
403
        # this batch call is a lot faster :).
284
404
        # (4 seconds to 1 seconds for the sample upgrades I was testing).
285
405
        self.write(''.join(lines))
286
406
 
 
407
    if sys.version_info > (2, 7):
 
408
        # As of Python 2.7 the crc32 must be positive when close is called
 
409
        def close(self):
 
410
            if self.fileobj is None:
 
411
                return
 
412
            if self.mode == gzip.WRITE:
 
413
                self.crc &= 0xFFFFFFFFL
 
414
            gzip.GzipFile.close(self)
287
415