← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tuned_gzip.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

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., 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
 
52
52
    width=-zlib.MAX_WBITS, mem=zlib.DEF_MEM_LEVEL,
53
53
    crc32=zlib.crc32):
54
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
    """
55
67
    result = [
56
68
        '\037\213'  # self.fileobj.write('\037\213')  # magic header
57
69
        '\010'      # self.fileobj.write('\010')      # compression method
69
81
    # using a compressobj avoids a small header and trailer that the compress()
70
82
    # utility function adds.
71
83
    compress = factory(level, method, width, mem, 0)
72
 
    result.append(compress.compress(bytes))
 
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)
73
92
    result.append(compress.flush())
74
 
    result.append(struct.pack("<L", LOWU32(crc32(bytes))))
75
93
    # size may exceed 2GB, or even 4GB
76
 
    result.append(struct.pack("<L", LOWU32(len(bytes))))
 
94
    result.append(struct.pack("<LL", LOWU32(crc), LOWU32(total_len)))
77
95
    return ''.join(result)
78
96
 
79
97
 
114
132
        """A tuned version of gzip._write_gzip_header
115
133
 
116
134
        We have some extra constrains that plain Gzip does not.
117
 
        1) We want to write the whole blob at once. rather than multiple 
 
135
        1) We want to write the whole blob at once. rather than multiple
118
136
           calls to fileobj.write().
119
137
        2) We never have a filename
120
138
        3) We don't care about the time
136
154
 
137
155
    def _read(self, size=1024):
138
156
        # various optimisations:
139
 
        # reduces lsprof count from 2500 to 
 
157
        # reduces lsprof count from 2500 to
140
158
        # 8337 calls in 1272, 365 internal
141
159
        if self.fileobj is None:
142
160
            raise EOFError, "Reached EOF"
207
225
        """tuned to reduce function calls and eliminate file seeking:
208
226
        pass 1:
209
227
        reduces lsprof count from 800 to 288
210
 
        4168 in 296 
 
228
        4168 in 296
211
229
        avoid U32 call by using struct format L
212
230
        4168 in 200
213
231
        """
214
 
        # 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
215
233
        # unused data in the decompressor. If we don't, there is a corrupt file.
216
234
        # We use these 8 bytes to calculate the CRC and the recorded file size.
217
235
        # We then check the that the computed CRC and size of the
228
246
 
229
247
    def _read_gzip_header(self, bytes=None):
230
248
        """Supply bytes if the minimum header size is already read.
231
 
        
 
249
 
232
250
        :param bytes: 10 bytes of header data.
233
251
        """
234
252
        """starting cost: 300 in 3998
271
289
 
272
290
    def readline(self, size=-1):
273
291
        """Tuned to remove buffer length calls in _unread and...
274
 
        
 
292
 
275
293
        also removes multiple len(c) calls, inlines _unread,
276
294
        total savings - lsprof 5800 to 5300
277
295
        phase 2:
281
299
        leading to a drop to:
282
300
        4168 calls in 1977
283
301
        4168 call to read() in 1646
284
 
        - i.e. just reduced the function call overhead. May be worth 
 
302
        - i.e. just reduced the function call overhead. May be worth
285
303
          keeping.
286
304
        """
287
305
        if size < 0: size = sys.maxint
329
347
        # to :
330
348
        # 4168 calls in 417.
331
349
        # Negative numbers result in reading all the lines
332
 
        
 
350
 
333
351
        # python's gzip routine uses sizehint. This is a more efficient way
334
352
        # than python uses to honor it. But it is even more efficient to
335
353
        # just read the entire thing and use cStringIO to split into lines.
342
360
 
343
361
    def _unread(self, buf, len_buf=None):
344
362
        """tuned to remove unneeded len calls.
345
 
        
 
363
 
346
364
        because this is such an inner routine in readline, and readline is
347
365
        in many inner loops, this has been inlined into readline().
348
366
 
349
367
        The len_buf parameter combined with the reduction in len calls dropped
350
 
        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 -
351
369
        a 75% saving.
352
370
        """
353
371
        if len_buf is None:
371
389
            self.offset += data_len
372
390
 
373
391
    def writelines(self, lines):
374
 
        # profiling indicated a significant overhead 
 
392
        # profiling indicated a significant overhead
375
393
        # calling write for each line.
376
394
        # this batch call is a lot faster :).
377
395
        # (4 seconds to 1 seconds for the sample upgrades I was testing).