diff-delta: big code simplification
This is much smaller and hopefully clearer code now. Signed-off-by: Nicolas Pitre <nico@cam.org> Signed-off-by: Junio C Hamano <junkio@cox.net>
Nicolas Pitre committed
Feb 21, 2006 at 20:43 UTC
8e1454b5ad285ec5dd25758e799c589045aff9d4
1 file changed
+85
-146
diff-delta.c
+85
-146
@@ -19,8 +19,9 @@
19
*/
20
21
#include <stdlib.h>
22
+#include <string.h>
23
+#include <zlib.h>
24
#include "delta.h"
23
-#include "zlib.h"
25
26
27
/* block size: min = 16, max = 64k, power of 2 */
@@ -29,123 +30,54 @@
30
#define MIN(a, b) ((a) < (b) ? (a) : (b))
31
32
#define GR_PRIME 0x9e370001
32
-#define HASH(v, b) (((unsigned int)(v) * GR_PRIME) >> (32 - (b)))
33
-
34
-static unsigned int hashbits(unsigned int size)
35
-{
36
- unsigned int val = 1, bits = 0;
37
- while (val < size && bits < 32) {
38
- val <<= 1;
39
- bits++;
40
- }
41
- return bits ? bits: 1;
42
-}
43
-
44
-typedef struct s_chanode {
45
- struct s_chanode *next;
46
- int icurr;
47
-} chanode_t;
48
-
49
-typedef struct s_chastore {
50
- int isize, nsize;
51
- chanode_t *ancur;
52
-} chastore_t;
53
-
54
-static void cha_init(chastore_t *cha, int isize, int icount)
55
-{
56
- cha->isize = isize;
57
- cha->nsize = icount * isize;
58
- cha->ancur = NULL;
59
-}
60
-
61
-static void *cha_alloc(chastore_t *cha)
62
-{
63
- chanode_t *ancur;
64
- void *data;
65
-
66
- ancur = cha->ancur;
67
- if (!ancur || ancur->icurr == cha->nsize) {
68
- ancur = malloc(sizeof(chanode_t) + cha->nsize);
69
- if (!ancur)
70
- return NULL;
71
- ancur->icurr = 0;
72
- ancur->next = cha->ancur;
73
- cha->ancur = ancur;
74
- }
75
-
76
- data = (void *)ancur + sizeof(chanode_t) + ancur->icurr;
77
- ancur->icurr += cha->isize;
78
- return data;
79
-}
80
-
81
-static void cha_free(chastore_t *cha)
82
-{
83
- chanode_t *cur = cha->ancur;
84
- while (cur) {
85
- chanode_t *tmp = cur;
86
- cur = cur->next;
87
- free(tmp);
88
- }
89
-}
33
+#define HASH(v, shift) (((unsigned int)(v) * GR_PRIME) >> (shift))
34
91
-typedef struct s_bdrecord {
92
- struct s_bdrecord *next;
93
- unsigned int fp;
35
+struct index {
36
const unsigned char *ptr;
95
-} bdrecord_t;
37
+ unsigned int val;
38
+ struct index *next;
39
+};
40
97
-typedef struct s_bdfile {
98
- chastore_t cha;
99
- unsigned int fphbits;
100
- bdrecord_t **fphash;
101
-} bdfile_t;
102
-
103
-static int delta_prepare(const unsigned char *buf, int bufsize, bdfile_t *bdf)
41
+static struct index ** delta_index(const unsigned char *buf,
42
+ unsigned long bufsize,
43
+ unsigned int *hash_shift)
44
{
105
- unsigned int fphbits;
106
- int i, hsize;
107
- const unsigned char *data, *top;
108
- bdrecord_t *brec;
109
- bdrecord_t **fphash;
110
-
111
- fphbits = hashbits(bufsize / BLK_SIZE + 1);
112
- hsize = 1 << fphbits;
113
- fphash = malloc(hsize * sizeof(bdrecord_t *));
114
- if (!fphash)
115
- return -1;
116
- for (i = 0; i < hsize; i++)
117
- fphash[i] = NULL;
118
- cha_init(&bdf->cha, sizeof(bdrecord_t), hsize / 4 + 1);
119
-
120
- top = buf + bufsize;
121
- data = buf + (bufsize / BLK_SIZE) * BLK_SIZE;
122
- if (data == top)
45
+ unsigned int hsize, hshift, entries, blksize, i;
46
+ const unsigned char *data;
47
+ struct index *entry, **hash;
48
+ void *mem;
49
+
50
+ /* determine index hash size */
51
+ entries = (bufsize + BLK_SIZE - 1) / BLK_SIZE;
52
+ hsize = entries / 4;
53
+ for (i = 4; (1 << i) < hsize && i < 16; i++);
54
+ hsize = 1 << i;
55
+ hshift = 32 - i;
56
+ *hash_shift = hshift;
57
+
58
+ /* allocate lookup index */
59
+ mem = malloc(hsize * sizeof(*hash) + entries * sizeof(*entry));
60
+ if (!mem)
61
+ return NULL;
62
+ hash = mem;
63
+ entry = mem + hsize * sizeof(*hash);
64
+ memset(hash, 0, hsize * sizeof(*hash));
65
+
66
+ /* then populate it */
67
+ data = buf + entries * BLK_SIZE - BLK_SIZE;
68
+ blksize = bufsize - (data - buf);
69
+ while (data >= buf) {
70
+ unsigned int val = adler32(0, data, blksize);
71
+ i = HASH(val, hshift);
72
+ entry->ptr = data;
73
+ entry->val = val;
74
+ entry->next = hash[i];
75
+ hash[i] = entry++;
76
+ blksize = BLK_SIZE;
77
data -= BLK_SIZE;
78
+ }
79
125
- for ( ; data >= buf; data -= BLK_SIZE) {
126
- brec = cha_alloc(&bdf->cha);
127
- if (!brec) {
128
- cha_free(&bdf->cha);
129
- free(fphash);
130
- return -1;
131
- }
132
- brec->fp = adler32(0, data, MIN(BLK_SIZE, top - data));
133
- brec->ptr = data;
134
- i = HASH(brec->fp, fphbits);
135
- brec->next = fphash[i];
136
- fphash[i] = brec;
137
- }
138
-
139
- bdf->fphbits = fphbits;
140
- bdf->fphash = fphash;
141
-
142
- return 0;
143
-}
144
-
145
-static void delta_cleanup(bdfile_t *bdf)
146
-{
147
- free(bdf->fphash);
148
- cha_free(&bdf->cha);
80
+ return hash;
81
}
82
83
/* provide the size of the copy opcode given the block offset and size */
@@ -161,23 +93,24 @@ void *diff_delta(void *from_buf, unsigned long from_size,
93
unsigned long *delta_size,
94
unsigned long max_size)
95
{
164
- unsigned int i, outpos, outsize, inscnt, csize, msize, moff;
165
- unsigned int fp;
166
- const unsigned char *ref_data, *ref_top, *data, *top, *ptr1, *ptr2;
167
- unsigned char *out, *orig;
168
- bdrecord_t *brec;
169
- bdfile_t bdf;
96
+ unsigned int i, outpos, outsize, inscnt, hash_shift;
97
+ const unsigned char *ref_data, *ref_top, *data, *top;
98
+ unsigned char *out;
99
+ struct index *entry, **hash;
100
171
- if (!from_size || !to_size || delta_prepare(from_buf, from_size, &bdf))
101
+ if (!from_size || !to_size)
102
return NULL;
173
-
103
+ hash = delta_index(from_buf, from_size, &hash_shift);
104
+ if (!hash)
105
+ return NULL;
106
+
107
outpos = 0;
108
outsize = 8192;
109
if (max_size && outsize >= max_size)
110
outsize = max_size + MAX_OP_SIZE + 1;
111
out = malloc(outsize);
112
if (!out) {
180
- delta_cleanup(&bdf);
113
+ free(hash);
114
return NULL;
115
}
116
@@ -205,28 +138,32 @@ void *diff_delta(void *from_buf, unsigned long from_size,
138
}
139
140
inscnt = 0;
208
- moff = 0;
209
- while (data < top) {
210
- msize = 0;
211
- fp = adler32(0, data, MIN(top - data, BLK_SIZE));
212
- i = HASH(fp, bdf.fphbits);
213
- for (brec = bdf.fphash[i]; brec; brec = brec->next) {
214
- if (brec->fp == fp) {
215
- csize = ref_top - brec->ptr;
216
- if (csize > top - data)
217
- csize = top - data;
218
- for (ptr1 = brec->ptr, ptr2 = data;
219
- csize && *ptr1 == *ptr2;
220
- csize--, ptr1++, ptr2++);
141
222
- csize = ptr1 - brec->ptr;
223
- if (csize > msize) {
224
- moff = brec->ptr - ref_data;
225
- msize = csize;
226
- if (msize >= 0x10000) {
227
- msize = 0x10000;
228
- break;
229
- }
142
+ while (data < top) {
143
+ unsigned int moff = 0, msize = 0;
144
+ unsigned int blksize = MIN(top - data, BLK_SIZE);
145
+ unsigned int val = adler32(0, data, blksize);
146
+ i = HASH(val, hash_shift);
147
+ for (entry = hash[i]; entry; entry = entry->next) {
148
+ const unsigned char *ref = entry->ptr;
149
+ const unsigned char *src = data;
150
+ unsigned int ref_size = ref_top - ref;
151
+ if (entry->val != val)
152
+ continue;
153
+ if (ref_size > top - src)
154
+ ref_size = top - src;
155
+ while (ref_size && *src++ == *ref) {
156
+ ref++;
157
+ ref_size--;
158
+ }
159
+ ref_size = ref - entry->ptr;
160
+ if (ref_size > msize) {
161
+ /* this is our best match so far */
162
+ moff = entry->ptr - ref_data;
163
+ msize = ref_size;
164
+ if (msize >= 0x10000) {
165
+ msize = 0x10000;
166
+ break;
167
}
168
}
169
}
@@ -241,13 +178,15 @@ void *diff_delta(void *from_buf, unsigned long from_size,
178
inscnt = 0;
179
}
180
} else {
181
+ unsigned char *op;
182
+
183
if (inscnt) {
184
out[outpos - inscnt - 1] = inscnt;
185
inscnt = 0;
186
}
187
188
data += msize;
250
- orig = out + outpos++;
189
+ op = out + outpos++;
190
i = 0x80;
191
192
if (moff & 0xff) { out[outpos++] = moff; i |= 0x01; }
@@ -262,7 +201,7 @@ void *diff_delta(void *from_buf, unsigned long from_size,
201
msize >>= 8;
202
if (msize & 0xff) { out[outpos++] = msize; i |= 0x20; }
203
265
- *orig = i;
204
+ *op = i;
205
}
206
207
if (outpos >= outsize - MAX_OP_SIZE) {
@@ -276,7 +215,7 @@ void *diff_delta(void *from_buf, unsigned long from_size,
215
out = realloc(out, outsize);
216
if (!out) {
217
free(tmp);
279
- delta_cleanup(&bdf);
218
+ free(hash);
219
return NULL;
220
}
221
}
@@ -285,7 +224,7 @@ void *diff_delta(void *from_buf, unsigned long from_size,
224
if (inscnt)
225
out[outpos - inscnt - 1] = inscnt;
226
288
- delta_cleanup(&bdf);
227
+ free(hash);
228
*delta_size = outpos;
229
return out;
230
}