← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tuned_gzip.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-25 21:50:11 UTC
  • mfrom: (0.11.3 tools)
  • mto: This revision was merged to the branch mainline in revision 3659.
  • Revision ID: john@arbash-meinel.com-20080825215011-de9esmzgkue3e522
Merge in Lukáš's helper scripts.
Update the packaging documents to describe how to do the releases
using bzr-builddeb to package all distro platforms
simultaneously.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tuned_gzip.py
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
 
21
21
 
22
22
# make GzipFile faster:
23
23
import gzip
24
 
from gzip import FEXTRA, FCOMMENT, FNAME, FHCRC
 
24
from gzip import U32, LOWU32, FEXTRA, FCOMMENT, FNAME, FHCRC
25
25
import sys
26
26
import struct
27
27
import zlib
32
32
__all__ = ["GzipFile", "bytes_to_gzip"]
33
33
 
34
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
35
def bytes_to_gzip(bytes, factory=zlib.compressobj,
51
36
    level=zlib.Z_DEFAULT_COMPRESSION, method=zlib.DEFLATED,
52
37
    width=-zlib.MAX_WBITS, mem=zlib.DEF_MEM_LEVEL,
53
38
    crc32=zlib.crc32):
54
39
    """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
40
    result = [
68
41
        '\037\213'  # self.fileobj.write('\037\213')  # magic header
69
42
        '\010'      # self.fileobj.write('\010')      # compression method
81
54
    # using a compressobj avoids a small header and trailer that the compress()
82
55
    # utility function adds.
83
56
    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)
 
57
    result.append(compress.compress(bytes))
92
58
    result.append(compress.flush())
 
59
    result.append(struct.pack("<L", LOWU32(crc32(bytes))))
93
60
    # size may exceed 2GB, or even 4GB
94
 
    result.append(struct.pack("<LL", LOWU32(crc), LOWU32(total_len)))
 
61
    result.append(struct.pack("<L", LOWU32(len(bytes))))
95
62
    return ''.join(result)
96
63
 
97
64
 
132
99
        """A tuned version of gzip._write_gzip_header
133
100
 
134
101
        We have some extra constrains that plain Gzip does not.
135
 
        1) We want to write the whole blob at once. rather than multiple
 
102
        1) We want to write the whole blob at once. rather than multiple 
136
103
           calls to fileobj.write().
137
104
        2) We never have a filename
138
105
        3) We don't care about the time
154
121
 
155
122
    def _read(self, size=1024):
156
123
        # various optimisations:
157
 
        # reduces lsprof count from 2500 to
 
124
        # reduces lsprof count from 2500 to 
158
125
        # 8337 calls in 1272, 365 internal
159
126
        if self.fileobj is None:
160
127
            raise EOFError, "Reached EOF"
225
192
        """tuned to reduce function calls and eliminate file seeking:
226
193
        pass 1:
227
194
        reduces lsprof count from 800 to 288
228
 
        4168 in 296
 
195
        4168 in 296 
229
196
        avoid U32 call by using struct format L
230
197
        4168 in 200
231
198
        """
232
 
        # We've read to the end of the file, so we should have 8 bytes of
 
199
        # We've read to the end of the file, so we should have 8 bytes of 
233
200
        # unused data in the decompressor. If we don't, there is a corrupt file.
234
201
        # We use these 8 bytes to calculate the CRC and the recorded file size.
235
202
        # We then check the that the computed CRC and size of the
246
213
 
247
214
    def _read_gzip_header(self, bytes=None):
248
215
        """Supply bytes if the minimum header size is already read.
249
 
 
 
216
        
250
217
        :param bytes: 10 bytes of header data.
251
218
        """
252
219
        """starting cost: 300 in 3998
289
256
 
290
257
    def readline(self, size=-1):
291
258
        """Tuned to remove buffer length calls in _unread and...
292
 
 
 
259
        
293
260
        also removes multiple len(c) calls, inlines _unread,
294
261
        total savings - lsprof 5800 to 5300
295
262
        phase 2:
299
266
        leading to a drop to:
300
267
        4168 calls in 1977
301
268
        4168 call to read() in 1646
302
 
        - i.e. just reduced the function call overhead. May be worth
 
269
        - i.e. just reduced the function call overhead. May be worth 
303
270
          keeping.
304
271
        """
305
272
        if size < 0: size = sys.maxint
347
314
        # to :
348
315
        # 4168 calls in 417.
349
316
        # Negative numbers result in reading all the lines
350
 
 
 
317
        
351
318
        # python's gzip routine uses sizehint. This is a more efficient way
352
319
        # than python uses to honor it. But it is even more efficient to
353
320
        # just read the entire thing and use cStringIO to split into lines.
360
327
 
361
328
    def _unread(self, buf, len_buf=None):
362
329
        """tuned to remove unneeded len calls.
363
 
 
 
330
        
364
331
        because this is such an inner routine in readline, and readline is
365
332
        in many inner loops, this has been inlined into readline().
366
333
 
367
334
        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 -
 
335
        the lsprof ms count for this routine on my test data from 800 to 200 - 
369
336
        a 75% saving.
370
337
        """
371
338
        if len_buf is None:
389
356
            self.offset += data_len
390
357
 
391
358
    def writelines(self, lines):
392
 
        # profiling indicated a significant overhead
 
359
        # profiling indicated a significant overhead 
393
360
        # calling write for each line.
394
361
        # this batch call is a lot faster :).
395
362
        # (4 seconds to 1 seconds for the sample upgrades I was testing).