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

  • Committer: Martin Pool
  • Date: 2006-04-18 04:38:44 UTC
  • mto: This revision was merged to the branch mainline in revision 1670.
  • Revision ID: mbp@sourcefrog.net-20060418043844-dbaac5bdecaed3d1
Clear out BRANCH.TODO - most of them are done now

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tuned_gzip.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
 
 
22
20
# make GzipFile faster:
23
21
import gzip
24
 
from gzip import FEXTRA, FCOMMENT, FNAME, FHCRC
 
22
from gzip import U32, LOWU32, FEXTRA, FCOMMENT, FNAME, FHCRC
25
23
import sys
26
24
import struct
27
25
import zlib
28
26
 
29
 
# we want a \n preserved, break on \n only splitlines.
30
 
import bzrlib
31
 
 
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)
 
27
__all__ = ["GzipFile"]
96
28
 
97
29
 
98
30
class GzipFile(gzip.GzipFile):
128
60
        self.extrasize += len_data
129
61
        self.size += len_data
130
62
 
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
 
 
155
63
    def _read(self, size=1024):
156
64
        # various optimisations:
157
 
        # reduces lsprof count from 2500 to
 
65
        # reduces lsprof count from 2500 to 
158
66
        # 8337 calls in 1272, 365 internal
159
67
        if self.fileobj is None:
160
68
            raise EOFError, "Reached EOF"
182
90
 
183
91
        if buf == "":
184
92
            self._add_read_data(self.decompress.flush())
185
 
            if len(self.decompress.unused_data) < 8:
186
 
                raise AssertionError("what does flush do?")
187
 
            self._gzip_tail = self.decompress.unused_data[0:8]
 
93
            assert len(self.decompress.unused_data) >= 8, "what does flush do?"
188
94
            self._read_eof()
189
95
            # tell the driving read() call we have stuffed all the data
190
96
            # in self.extrabuf
203
109
            # (The number of bytes to seek back is the length of the unused
204
110
            # data, minus 8 because those 8 bytes are part of this member.
205
111
            seek_length = len (self.decompress.unused_data) - 8
206
 
            if seek_length > 0:
207
 
                # we read too much data
 
112
            if seek_length:
 
113
                assert seek_length > 0
208
114
                self.fileobj.seek(-seek_length, 1)
209
 
                self._gzip_tail = self.decompress.unused_data[0:8]
210
 
            elif seek_length < 0:
211
 
                # we haven't read enough to check the checksum.
212
 
                if not (-8 < seek_length):
213
 
                    raise AssertionError("too great a seek")
214
 
                buf = self.fileobj.read(-seek_length)
215
 
                self._gzip_tail = self.decompress.unused_data + buf
216
 
            else:
217
 
                self._gzip_tail = self.decompress.unused_data
218
115
 
219
116
            # Check the CRC and file size, and set the flag so we read
220
117
            # a new member on the next call
225
122
        """tuned to reduce function calls and eliminate file seeking:
226
123
        pass 1:
227
124
        reduces lsprof count from 800 to 288
228
 
        4168 in 296
 
125
        4168 in 296 
229
126
        avoid U32 call by using struct format L
230
127
        4168 in 200
231
128
        """
232
 
        # We've read to the end of the file, so we should have 8 bytes of
233
 
        # unused data in the decompressor. If we don't, there is a corrupt file.
 
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.
234
131
        # We use these 8 bytes to calculate the CRC and the recorded file size.
235
132
        # We then check the that the computed CRC and size of the
236
133
        # uncompressed data matches the stored values.  Note that the size
237
134
        # stored is the true file size mod 2**32.
238
 
        if not (len(self._gzip_tail) == 8):
239
 
            raise AssertionError("gzip trailer is incorrect length.")
240
 
        crc32, isize = struct.unpack("<LL", self._gzip_tail)
 
135
        crc32, isize = struct.unpack("<LL", self.decompress.unused_data[0:8])
241
136
        # note that isize is unsigned - it can exceed 2GB
242
137
        if crc32 != U32(self.crc):
243
 
            raise IOError, "CRC check failed %d %d" % (crc32, U32(self.crc))
 
138
            raise IOError, "CRC check failed"
244
139
        elif isize != LOWU32(self.size):
245
140
            raise IOError, "Incorrect length of data produced"
246
141
 
247
142
    def _read_gzip_header(self, bytes=None):
248
143
        """Supply bytes if the minimum header size is already read.
249
 
 
 
144
        
250
145
        :param bytes: 10 bytes of header data.
251
146
        """
252
147
        """starting cost: 300 in 3998
289
184
 
290
185
    def readline(self, size=-1):
291
186
        """Tuned to remove buffer length calls in _unread and...
292
 
 
 
187
        
293
188
        also removes multiple len(c) calls, inlines _unread,
294
189
        total savings - lsprof 5800 to 5300
295
190
        phase 2:
299
194
        leading to a drop to:
300
195
        4168 calls in 1977
301
196
        4168 call to read() in 1646
302
 
        - i.e. just reduced the function call overhead. May be worth
 
197
        - i.e. just reduced the function call overhead. May be worth 
303
198
          keeping.
304
199
        """
305
200
        if size < 0: size = sys.maxint
347
242
        # to :
348
243
        # 4168 calls in 417.
349
244
        # Negative numbers result in reading all the lines
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()
 
245
        if sizehint <= 0:
 
246
            sizehint = -1
 
247
        content = self.read(sizehint)
 
248
        return content.splitlines(True)
360
249
 
361
250
    def _unread(self, buf, len_buf=None):
362
251
        """tuned to remove unneeded len calls.
363
 
 
 
252
        
364
253
        because this is such an inner routine in readline, and readline is
365
254
        in many inner loops, this has been inlined into readline().
366
255
 
367
256
        The len_buf parameter combined with the reduction in len calls dropped
368
 
        the lsprof ms count for this routine on my test data from 800 to 200 -
 
257
        the lsprof ms count for this routine on my test data from 800 to 200 - 
369
258
        a 75% saving.
370
259
        """
371
260
        if len_buf is None:
389
278
            self.offset += data_len
390
279
 
391
280
    def writelines(self, lines):
392
 
        # profiling indicated a significant overhead
 
281
        # profiling indicated a significant overhead 
393
282
        # calling write for each line.
394
283
        # this batch call is a lot faster :).
395
284
        # (4 seconds to 1 seconds for the sample upgrades I was testing).