← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tuned_gzip.py

  • Committer: Gary van der Merwe
  • Date: 2009-12-01 11:08:28 UTC
  • mto: This revision was merged to the branch mainline in revision 4862.
  • Revision ID: garyvdm@gmail.com-20091201110828-o6yxb3kz82v0o6vu
https://launchpad.net/bugs/490738
When launching an external diff app, don't write temporary files for a working tree.

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) 2005, 2006 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 cStringIO import StringIO
 
21
 
20
22
# make GzipFile faster:
21
23
import gzip
22
 
from gzip import U32, LOWU32, FEXTRA, FCOMMENT, FNAME, FHCRC
 
24
from gzip import FEXTRA, FCOMMENT, FNAME, FHCRC
23
25
import sys
24
26
import struct
25
27
import zlib
27
29
# we want a \n preserved, break on \n only splitlines.
28
30
import bzrlib
29
31
 
30
 
__all__ = ["GzipFile"]
 
32
__all__ = ["GzipFile", "bytes_to_gzip"]
 
33
 
 
34
 
 
35
def U32(i):
 
36
    """Return i as an unsigned integer, assuming it fits in 32 bits.
 
37
 
 
38
    If it's >= 2GB when viewed as a 32-bit unsigned int, return a long.
 
39
    """
 
40
    if i < 0:
 
41
        i += 1L << 32
 
42
    return i
 
43
 
 
44
 
 
45
def LOWU32(i):
 
46
    """Return the low-order 32 bits of an int, as a non-negative int."""
 
47
    return i & 0xFFFFFFFFL
 
48
 
 
49
 
 
50
def bytes_to_gzip(bytes, factory=zlib.compressobj,
 
51
    level=zlib.Z_DEFAULT_COMPRESSION, method=zlib.DEFLATED,
 
52
    width=-zlib.MAX_WBITS, mem=zlib.DEF_MEM_LEVEL,
 
53
    crc32=zlib.crc32):
 
54
    """Create a gzip file containing bytes and return its content."""
 
55
    return chunks_to_gzip([bytes])
 
56
 
 
57
 
 
58
def chunks_to_gzip(chunks, factory=zlib.compressobj,
 
59
    level=zlib.Z_DEFAULT_COMPRESSION, method=zlib.DEFLATED,
 
60
    width=-zlib.MAX_WBITS, mem=zlib.DEF_MEM_LEVEL,
 
61
    crc32=zlib.crc32):
 
62
    """Create a gzip file containing chunks and return its content.
 
63
 
 
64
    :param chunks: An iterable of strings. Each string can have arbitrary
 
65
        layout.
 
66
    """
 
67
    result = [
 
68
        '\037\213'  # self.fileobj.write('\037\213')  # magic header
 
69
        '\010'      # self.fileobj.write('\010')      # compression method
 
70
                    # fname = self.filename[:-3]
 
71
                    # flags = 0
 
72
                    # if fname:
 
73
                    #     flags = FNAME
 
74
        '\x00'      # self.fileobj.write(chr(flags))
 
75
        '\0\0\0\0'  # write32u(self.fileobj, long(time.time()))
 
76
        '\002'      # self.fileobj.write('\002')
 
77
        '\377'      # self.fileobj.write('\377')
 
78
                    # if fname:
 
79
        ''          #     self.fileobj.write(fname + '\000')
 
80
        ]
 
81
    # using a compressobj avoids a small header and trailer that the compress()
 
82
    # utility function adds.
 
83
    compress = factory(level, method, width, mem, 0)
 
84
    crc = 0
 
85
    total_len = 0
 
86
    for chunk in chunks:
 
87
        crc = crc32(chunk, crc)
 
88
        total_len += len(chunk)
 
89
        zbytes = compress.compress(chunk)
 
90
        if zbytes:
 
91
            result.append(zbytes)
 
92
    result.append(compress.flush())
 
93
    # size may exceed 2GB, or even 4GB
 
94
    result.append(struct.pack("<LL", LOWU32(crc), LOWU32(total_len)))
 
95
    return ''.join(result)
31
96
 
32
97
 
33
98
class GzipFile(gzip.GzipFile):
63
128
        self.extrasize += len_data
64
129
        self.size += len_data
65
130
 
 
131
    def _write_gzip_header(self):
 
132
        """A tuned version of gzip._write_gzip_header
 
133
 
 
134
        We have some extra constrains that plain Gzip does not.
 
135
        1) We want to write the whole blob at once. rather than multiple
 
136
           calls to fileobj.write().
 
137
        2) We never have a filename
 
138
        3) We don't care about the time
 
139
        """
 
140
        self.fileobj.write(
 
141
           '\037\213'   # self.fileobj.write('\037\213')  # magic header
 
142
            '\010'      # self.fileobj.write('\010')      # compression method
 
143
                        # fname = self.filename[:-3]
 
144
                        # flags = 0
 
145
                        # if fname:
 
146
                        #     flags = FNAME
 
147
            '\x00'      # self.fileobj.write(chr(flags))
 
148
            '\0\0\0\0'  # write32u(self.fileobj, long(time.time()))
 
149
            '\002'      # self.fileobj.write('\002')
 
150
            '\377'      # self.fileobj.write('\377')
 
151
                        # if fname:
 
152
            ''          #     self.fileobj.write(fname + '\000')
 
153
            )
 
154
 
66
155
    def _read(self, size=1024):
67
156
        # various optimisations:
68
 
        # reduces lsprof count from 2500 to 
 
157
        # reduces lsprof count from 2500 to
69
158
        # 8337 calls in 1272, 365 internal
70
159
        if self.fileobj is None:
71
160
            raise EOFError, "Reached EOF"
93
182
 
94
183
        if buf == "":
95
184
            self._add_read_data(self.decompress.flush())
96
 
            assert len(self.decompress.unused_data) >= 8, "what does flush do?"
 
185
            if len(self.decompress.unused_data) < 8:
 
186
                raise AssertionError("what does flush do?")
97
187
            self._gzip_tail = self.decompress.unused_data[0:8]
98
188
            self._read_eof()
99
189
            # tell the driving read() call we have stuffed all the data
119
209
                self._gzip_tail = self.decompress.unused_data[0:8]
120
210
            elif seek_length < 0:
121
211
                # we haven't read enough to check the checksum.
122
 
                assert -8 < seek_length, "too great a seek."
 
212
                if not (-8 < seek_length):
 
213
                    raise AssertionError("too great a seek")
123
214
                buf = self.fileobj.read(-seek_length)
124
215
                self._gzip_tail = self.decompress.unused_data + buf
125
216
            else:
134
225
        """tuned to reduce function calls and eliminate file seeking:
135
226
        pass 1:
136
227
        reduces lsprof count from 800 to 288
137
 
        4168 in 296 
 
228
        4168 in 296
138
229
        avoid U32 call by using struct format L
139
230
        4168 in 200
140
231
        """
141
 
        # We've read to the end of the file, so we should have 8 bytes of 
 
232
        # We've read to the end of the file, so we should have 8 bytes of
142
233
        # unused data in the decompressor. If we don't, there is a corrupt file.
143
234
        # We use these 8 bytes to calculate the CRC and the recorded file size.
144
235
        # We then check the that the computed CRC and size of the
145
236
        # uncompressed data matches the stored values.  Note that the size
146
237
        # stored is the true file size mod 2**32.
147
 
        assert len(self._gzip_tail) == 8, "gzip trailer is incorrect length."
 
238
        if not (len(self._gzip_tail) == 8):
 
239
            raise AssertionError("gzip trailer is incorrect length.")
148
240
        crc32, isize = struct.unpack("<LL", self._gzip_tail)
149
241
        # note that isize is unsigned - it can exceed 2GB
150
242
        if crc32 != U32(self.crc):
154
246
 
155
247
    def _read_gzip_header(self, bytes=None):
156
248
        """Supply bytes if the minimum header size is already read.
157
 
        
 
249
 
158
250
        :param bytes: 10 bytes of header data.
159
251
        """
160
252
        """starting cost: 300 in 3998
197
289
 
198
290
    def readline(self, size=-1):
199
291
        """Tuned to remove buffer length calls in _unread and...
200
 
        
 
292
 
201
293
        also removes multiple len(c) calls, inlines _unread,
202
294
        total savings - lsprof 5800 to 5300
203
295
        phase 2:
207
299
        leading to a drop to:
208
300
        4168 calls in 1977
209
301
        4168 call to read() in 1646
210
 
        - i.e. just reduced the function call overhead. May be worth 
 
302
        - i.e. just reduced the function call overhead. May be worth
211
303
          keeping.
212
304
        """
213
305
        if size < 0: size = sys.maxint
255
347
        # to :
256
348
        # 4168 calls in 417.
257
349
        # Negative numbers result in reading all the lines
258
 
        if sizehint <= 0:
259
 
            sizehint = -1
260
 
        content = self.read(sizehint)
261
 
        return bzrlib.osutils.split_lines(content)
 
350
 
 
351
        # python's gzip routine uses sizehint. This is a more efficient way
 
352
        # than python uses to honor it. But it is even more efficient to
 
353
        # just read the entire thing and use cStringIO to split into lines.
 
354
        # if sizehint <= 0:
 
355
        #     sizehint = -1
 
356
        # content = self.read(sizehint)
 
357
        # return bzrlib.osutils.split_lines(content)
 
358
        content = StringIO(self.read(-1))
 
359
        return content.readlines()
262
360
 
263
361
    def _unread(self, buf, len_buf=None):
264
362
        """tuned to remove unneeded len calls.
265
 
        
 
363
 
266
364
        because this is such an inner routine in readline, and readline is
267
365
        in many inner loops, this has been inlined into readline().
268
366
 
269
367
        The len_buf parameter combined with the reduction in len calls dropped
270
 
        the lsprof ms count for this routine on my test data from 800 to 200 - 
 
368
        the lsprof ms count for this routine on my test data from 800 to 200 -
271
369
        a 75% saving.
272
370
        """
273
371
        if len_buf is None:
291
389
            self.offset += data_len
292
390
 
293
391
    def writelines(self, lines):
294
 
        # profiling indicated a significant overhead 
 
392
        # profiling indicated a significant overhead
295
393
        # calling write for each line.
296
394
        # this batch call is a lot faster :).
297
395
        # (4 seconds to 1 seconds for the sample upgrades I was testing).