← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_groupcompress_pyx.pyx

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_groupcompress_pyx.pyx
1
 
# Copyright (C) 2009 Canonical Ltd
 
1
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
22
22
 
23
23
 
24
24
cdef extern from "Python.h":
 
25
    ctypedef struct PyObject:
 
26
        pass
25
27
    ctypedef int Py_ssize_t # Required for older pyrex versions
26
28
    int PyString_CheckExact(object)
27
29
    char * PyString_AS_STRING(object)
31
33
 
32
34
cdef extern from *:
33
35
    ctypedef unsigned long size_t
34
 
    void * malloc(size_t)
35
 
    void * realloc(void *, size_t)
36
 
    void free(void *)
37
 
    void memcpy(void *, void *, size_t)
 
36
    void * malloc(size_t) nogil
 
37
    void * realloc(void *, size_t) nogil
 
38
    void free(void *) nogil
 
39
    void memcpy(void *, void *, size_t) nogil
38
40
 
39
41
 
40
42
cdef extern from "delta.h":
44
46
        unsigned long agg_offset
45
47
    struct delta_index:
46
48
        pass
47
 
    delta_index * create_delta_index(source_info *src, delta_index *old)
 
49
    delta_index * create_delta_index(source_info *src, delta_index *old) nogil
48
50
    delta_index * create_delta_index_from_delta(source_info *delta,
49
 
                                                delta_index *old)
50
 
    void free_delta_index(delta_index *index)
 
51
                                                delta_index *old) nogil
 
52
    void free_delta_index(delta_index *index) nogil
51
53
    void *create_delta(delta_index *indexes,
52
54
             void *buf, unsigned long bufsize,
53
 
             unsigned long *delta_size, unsigned long max_delta_size)
 
55
             unsigned long *delta_size, unsigned long max_delta_size) nogil
54
56
    unsigned long get_delta_hdr_size(unsigned char **datap,
55
 
                                     unsigned char *top)
 
57
                                     unsigned char *top) nogil
 
58
    unsigned long sizeof_delta_index(delta_index *index)
56
59
    Py_ssize_t DELTA_SIZE_MIN
57
 
    void *patch_delta(void *src_buf, unsigned long src_size,
58
 
                      void *delta_buf, unsigned long delta_size,
59
 
                      unsigned long *dst_size)
60
60
 
61
61
 
62
62
cdef void *safe_malloc(size_t count) except NULL:
94
94
    cdef readonly object _sources
95
95
    cdef source_info *_source_infos
96
96
    cdef delta_index *_index
 
97
    cdef public unsigned long _source_offset
97
98
    cdef readonly unsigned int _max_num_sources
98
 
    cdef public unsigned long _source_offset
99
99
 
100
100
    def __init__(self, source=None):
101
101
        self._sources = []
108
108
        if source is not None:
109
109
            self.add_source(source, 0)
110
110
 
 
111
    def __sizeof__(self):
 
112
        # We want to track the _source_infos allocations, but the referenced
 
113
        # void* are actually tracked in _sources itself.
 
114
        # XXX: Cython is capable of doing sizeof(class) and returning the size
 
115
        #      of the underlying struct. Pyrex (<= 0.9.9) refuses, so we need
 
116
        #      to do it manually. *sigh* Note that we might get it wrong
 
117
        #      because of alignment issues.
 
118
        cdef Py_ssize_t size
 
119
        # PyObject start, vtable *, 3 object pointers, 2 C ints
 
120
        size = ((sizeof(PyObject) + sizeof(void*) + 3*sizeof(PyObject*)
 
121
                 + sizeof(unsigned long)
 
122
                 + sizeof(unsigned int))
 
123
                + (sizeof(source_info) * self._max_num_sources)
 
124
                + sizeof_delta_index(self._index))
 
125
        return size
 
126
 
111
127
    def __repr__(self):
112
128
        return '%s(%d, %d)' % (self.__class__.__name__,
113
129
            len(self._sources), self._source_offset)
148
164
        src.buf = c_delta
149
165
        src.size = c_delta_size
150
166
        src.agg_offset = self._source_offset + unadded_bytes
151
 
        index = create_delta_index_from_delta(src, self._index)
 
167
        with nogil:
 
168
            index = create_delta_index_from_delta(src, self._index)
152
169
        self._source_offset = src.agg_offset + src.size
153
170
        if index != NULL:
154
171
            free_delta_index(self._index)
188
205
        self._source_offset = src.agg_offset + src.size
189
206
        # We delay creating the index on the first insert
190
207
        if source_location != 0:
191
 
            index = create_delta_index(src, self._index)
 
208
            with nogil:
 
209
                index = create_delta_index(src, self._index)
192
210
            if index != NULL:
193
211
                free_delta_index(self._index)
194
212
                self._index = index
201
219
 
202
220
        # We know that self._index is already NULL, so whatever
203
221
        # create_delta_index returns is fine
204
 
        self._index = create_delta_index(&self._source_infos[0], NULL)
 
222
        with nogil:
 
223
            self._index = create_delta_index(&self._source_infos[0], NULL)
205
224
        assert self._index != NULL
206
225
 
207
226
    cdef _expand_sources(self):
218
237
        cdef Py_ssize_t target_size
219
238
        cdef void * delta
220
239
        cdef unsigned long delta_size
 
240
        cdef unsigned long c_max_delta_size
221
241
 
222
242
        if self._index == NULL:
223
243
            if len(self._sources) == 0:
234
254
        # TODO: inline some of create_delta so we at least don't have to double
235
255
        #       malloc, and can instead use PyString_FromStringAndSize, to
236
256
        #       allocate the bytes into the final string
237
 
        delta = create_delta(self._index,
238
 
                             target, target_size,
239
 
                             &delta_size, max_delta_size)
 
257
        c_max_delta_size = max_delta_size
 
258
        with nogil:
 
259
            delta = create_delta(self._index,
 
260
                                 target, target_size,
 
261
                                 &delta_size, c_max_delta_size)
240
262
        result = None
241
263
        if delta:
242
264
            result = PyString_FromStringAndSize(<char *>delta, delta_size)
276
298
 
277
299
 
278
300
cdef unsigned char *_decode_copy_instruction(unsigned char *bytes,
279
 
    unsigned char cmd, unsigned int *offset, unsigned int *length):
 
301
    unsigned char cmd, unsigned int *offset,
 
302
    unsigned int *length) nogil: # cannot_raise
280
303
    """Decode a copy instruction from the next few bytes.
281
304
 
282
305
    A copy instruction is a variable number of bytes, so we will parse the
326
349
    cdef unsigned char *dst_buf, *out, cmd
327
350
    cdef Py_ssize_t size
328
351
    cdef unsigned int cp_off, cp_size
 
352
    cdef int failed
329
353
 
330
354
    data = <unsigned char *>delta
331
355
    top = data + delta_size
335
359
    result = PyString_FromStringAndSize(NULL, size)
336
360
    dst_buf = <unsigned char*>PyString_AS_STRING(result)
337
361
 
338
 
    out = dst_buf
339
 
    while (data < top):
340
 
        cmd = data[0]
341
 
        data = data + 1
342
 
        if (cmd & 0x80):
343
 
            # Copy instruction
344
 
            data = _decode_copy_instruction(data, cmd, &cp_off, &cp_size)
345
 
            if (cp_off + cp_size < cp_size or
346
 
                cp_off + cp_size > source_size or
347
 
                cp_size > size):
348
 
                raise RuntimeError('Something wrong with:'
349
 
                    ' cp_off = %s, cp_size = %s'
350
 
                    ' source_size = %s, size = %s'
351
 
                    % (cp_off, cp_size, source_size, size))
352
 
            memcpy(out, source + cp_off, cp_size)
353
 
            out = out + cp_size
354
 
            size = size - cp_size
355
 
        else:
356
 
            # Insert instruction
357
 
            if cmd == 0:
358
 
                # cmd == 0 is reserved for future encoding
359
 
                # extensions. In the mean time we must fail when
360
 
                # encountering them (might be data corruption).
361
 
                raise RuntimeError('Got delta opcode: 0, not supported')
362
 
            if (cmd > size):
363
 
                raise RuntimeError('Insert instruction longer than remaining'
364
 
                    ' bytes: %d > %d' % (cmd, size))
365
 
            memcpy(out, data, cmd)
366
 
            out = out + cmd
367
 
            data = data + cmd
368
 
            size = size - cmd
 
362
    failed = 0
 
363
    with nogil:
 
364
        out = dst_buf
 
365
        while (data < top):
 
366
            cmd = data[0]
 
367
            data = data + 1
 
368
            if (cmd & 0x80):
 
369
                # Copy instruction
 
370
                data = _decode_copy_instruction(data, cmd, &cp_off, &cp_size)
 
371
                if (cp_off + cp_size < cp_size or
 
372
                    cp_off + cp_size > source_size or
 
373
                    cp_size > size):
 
374
                    failed = 1
 
375
                    break
 
376
                memcpy(out, source + cp_off, cp_size)
 
377
                out = out + cp_size
 
378
                size = size - cp_size
 
379
            else:
 
380
                # Insert instruction
 
381
                if cmd == 0:
 
382
                    # cmd == 0 is reserved for future encoding
 
383
                    # extensions. In the mean time we must fail when
 
384
                    # encountering them (might be data corruption).
 
385
                    failed = 2
 
386
                    break
 
387
                if cmd > size:
 
388
                    failed = 3
 
389
                    break
 
390
                memcpy(out, data, cmd)
 
391
                out = out + cmd
 
392
                data = data + cmd
 
393
                size = size - cmd
 
394
    if failed:
 
395
        if failed == 1:
 
396
            raise ValueError('Something wrong with:'
 
397
                ' cp_off = %s, cp_size = %s'
 
398
                ' source_size = %s, size = %s'
 
399
                % (cp_off, cp_size, source_size, size))
 
400
        elif failed == 2:
 
401
            raise ValueError('Got delta opcode: 0, not supported')
 
402
        elif failed == 3:
 
403
            raise ValueError('Insert instruction longer than remaining'
 
404
                ' bytes: %d > %d' % (cmd, size))
369
405
 
370
406
    # sanity check
371
407
    if (data != top or size != 0):