teach git-unpack-objects about deltas with offset to base
For delta resolution to be possible, a list of sha1/offset tuple must be constructed in memory in order to load the appropriate base object. Signed-off-by: Nicolas Pitre <nico@cam.org> Signed-off-by: Junio C Hamano <junkio@cox.net>
Nicolas Pitre committed
Sep 21, 2006 at 00:07 UTC
209c554ab45701fb78de77fdcec803fef2c8fd39
1 file changed
+106
-32
builtin-unpack-objects.c
+106
-32
@@ -15,7 +15,7 @@ static const char unpack_usage[] = "git-unpack-objects [-n] [-q] [-r] < pack-fil
15
16
/* We always read in 4kB chunks. */
17
static unsigned char buffer[4096];
18
-static unsigned long offset, len;
18
+static unsigned long offset, len, consumed_bytes;
19
static SHA_CTX ctx;
20
21
/*
@@ -51,6 +51,7 @@ static void use(int bytes)
51
die("used more bytes than were available");
52
len -= bytes;
53
offset += bytes;
54
+ consumed_bytes += bytes;
55
}
56
57
static void *get_data(unsigned long size)
@@ -89,35 +90,49 @@ static void *get_data(unsigned long size)
90
91
struct delta_info {
92
unsigned char base_sha1[20];
93
+ unsigned long base_offset;
94
unsigned long size;
95
void *delta;
96
+ unsigned nr;
97
struct delta_info *next;
98
};
99
100
static struct delta_info *delta_list;
101
99
-static void add_delta_to_list(unsigned char *base_sha1, void *delta, unsigned long size)
102
+static void add_delta_to_list(unsigned nr, unsigned const char *base_sha1,
103
+ unsigned long base_offset,
104
+ void *delta, unsigned long size)
105
{
106
struct delta_info *info = xmalloc(sizeof(*info));
107
108
hashcpy(info->base_sha1, base_sha1);
109
+ info->base_offset = base_offset;
110
info->size = size;
111
info->delta = delta;
112
+ info->nr = nr;
113
info->next = delta_list;
114
delta_list = info;
115
}
116
110
-static void added_object(unsigned char *sha1, const char *type, void *data, unsigned long size);
117
+struct obj_info {
118
+ unsigned long offset;
119
+ unsigned char sha1[20];
120
+};
121
+
122
+static struct obj_info *obj_list;
123
112
-static void write_object(void *buf, unsigned long size, const char *type)
124
+static void added_object(unsigned nr, const char *type, void *data,
125
+ unsigned long size);
126
+
127
+static void write_object(unsigned nr, void *buf, unsigned long size,
128
+ const char *type)
129
{
114
- unsigned char sha1[20];
115
- if (write_sha1_file(buf, size, type, sha1) < 0)
130
+ if (write_sha1_file(buf, size, type, obj_list[nr].sha1) < 0)
131
die("failed to write object");
117
- added_object(sha1, type, buf, size);
132
+ added_object(nr, type, buf, size);
133
}
134
120
-static void resolve_delta(const char *type,
135
+static void resolve_delta(unsigned nr, const char *type,
136
void *base, unsigned long base_size,
137
void *delta, unsigned long delta_size)
138
{
@@ -130,20 +145,23 @@ static void resolve_delta(const char *type,
145
if (!result)
146
die("failed to apply delta");
147
free(delta);
133
- write_object(result, result_size, type);
148
+ write_object(nr, result, result_size, type);
149
free(result);
150
}
151
137
-static void added_object(unsigned char *sha1, const char *type, void *data, unsigned long size)
152
+static void added_object(unsigned nr, const char *type, void *data,
153
+ unsigned long size)
154
{
155
struct delta_info **p = &delta_list;
156
struct delta_info *info;
157
158
while ((info = *p) != NULL) {
143
- if (!hashcmp(info->base_sha1, sha1)) {
159
+ if (!hashcmp(info->base_sha1, obj_list[nr].sha1) ||
160
+ info->base_offset == obj_list[nr].offset) {
161
*p = info->next;
162
p = &delta_list;
146
- resolve_delta(type, data, size, info->delta, info->size);
163
+ resolve_delta(info->nr, type, data, size,
164
+ info->delta, info->size);
165
free(info);
166
continue;
167
}
@@ -151,7 +169,8 @@ static void added_object(unsigned char *sha1, const char *type, void *data, unsi
169
}
170
}
171
154
-static void unpack_non_delta_entry(enum object_type kind, unsigned long size)
172
+static void unpack_non_delta_entry(enum object_type kind, unsigned long size,
173
+ unsigned nr)
174
{
175
void *buf = get_data(size);
176
const char *type;
@@ -164,30 +183,80 @@ static void unpack_non_delta_entry(enum object_type kind, unsigned long size)
183
default: die("bad type %d", kind);
184
}
185
if (!dry_run && buf)
167
- write_object(buf, size, type);
186
+ write_object(nr, buf, size, type);
187
free(buf);
188
}
189
171
-static void unpack_delta_entry(unsigned long delta_size)
190
+static void unpack_delta_entry(enum object_type kind, unsigned long delta_size,
191
+ unsigned nr)
192
{
193
void *delta_data, *base;
194
unsigned long base_size;
195
char type[20];
196
unsigned char base_sha1[20];
197
178
- hashcpy(base_sha1, fill(20));
179
- use(20);
198
+ if (kind == OBJ_REF_DELTA) {
199
+ hashcpy(base_sha1, fill(20));
200
+ use(20);
201
+ delta_data = get_data(delta_size);
202
+ if (dry_run || !delta_data) {
203
+ free(delta_data);
204
+ return;
205
+ }
206
+ if (!has_sha1_file(base_sha1)) {
207
+ hashcpy(obj_list[nr].sha1, null_sha1);
208
+ add_delta_to_list(nr, base_sha1, 0, delta_data, delta_size);
209
+ return;
210
+ }
211
+ } else {
212
+ unsigned base_found = 0;
213
+ unsigned char *pack, c;
214
+ unsigned long base_offset;
215
+ unsigned lo, mid, hi;
216
181
- delta_data = get_data(delta_size);
182
- if (dry_run || !delta_data) {
183
- free(delta_data);
184
- return;
185
- }
217
+ pack = fill(1);
218
+ c = *pack;
219
+ use(1);
220
+ base_offset = c & 127;
221
+ while (c & 128) {
222
+ base_offset += 1;
223
+ if (!base_offset || base_offset & ~(~0UL >> 7))
224
+ die("offset value overflow for delta base object");
225
+ pack = fill(1);
226
+ c = *pack;
227
+ use(1);
228
+ base_offset = (base_offset << 7) + (c & 127);
229
+ }
230
+ base_offset = obj_list[nr].offset - base_offset;
231
187
- if (!has_sha1_file(base_sha1)) {
188
- add_delta_to_list(base_sha1, delta_data, delta_size);
189
- return;
232
+ delta_data = get_data(delta_size);
233
+ if (dry_run || !delta_data) {
234
+ free(delta_data);
235
+ return;
236
+ }
237
+ lo = 0;
238
+ hi = nr;
239
+ while (lo < hi) {
240
+ mid = (lo + hi)/2;
241
+ if (base_offset < obj_list[mid].offset) {
242
+ hi = mid;
243
+ } else if (base_offset > obj_list[mid].offset) {
244
+ lo = mid + 1;
245
+ } else {
246
+ hashcpy(base_sha1, obj_list[mid].sha1);
247
+ base_found = !is_null_sha1(base_sha1);
248
+ break;
249
+ }
250
+ }
251
+ if (!base_found) {
252
+ /* The delta base object is itself a delta that
253
+ has not been resolved yet. */
254
+ hashcpy(obj_list[nr].sha1, null_sha1);
255
+ add_delta_to_list(nr, null_sha1, base_offset, delta_data, delta_size);
256
+ return;
257
+ }
258
}
259
+
260
base = read_sha1_file(base_sha1, type, &base_size);
261
if (!base) {
262
error("failed to read delta-pack base object %s",
@@ -197,7 +266,7 @@ static void unpack_delta_entry(unsigned long delta_size)
266
has_errors = 1;
267
return;
268
}
200
- resolve_delta(type, base, base_size, delta_data, delta_size);
269
+ resolve_delta(nr, type, base, base_size, delta_data, delta_size);
270
free(base);
271
}
272
@@ -208,6 +277,8 @@ static void unpack_one(unsigned nr, unsigned total)
277
unsigned long size;
278
enum object_type type;
279
280
+ obj_list[nr].offset = consumed_bytes;
281
+
282
pack = fill(1);
283
c = *pack;
284
use(1);
@@ -216,7 +287,7 @@ static void unpack_one(unsigned nr, unsigned total)
287
shift = 4;
288
while (c & 0x80) {
289
pack = fill(1);
219
- c = *pack++;
290
+ c = *pack;
291
use(1);
292
size += (c & 0x7f) << shift;
293
shift += 7;
@@ -225,13 +296,14 @@ static void unpack_one(unsigned nr, unsigned total)
296
static unsigned long last_sec;
297
static unsigned last_percent;
298
struct timeval now;
228
- unsigned percentage = (nr * 100) / total;
299
+ unsigned percentage = ((nr+1) * 100) / total;
300
301
gettimeofday(&now, NULL);
302
if (percentage != last_percent || now.tv_sec != last_sec) {
303
last_sec = now.tv_sec;
304
last_percent = percentage;
234
- fprintf(stderr, "%4u%% (%u/%u) done\r", percentage, nr, total);
305
+ fprintf(stderr, "%4u%% (%u/%u) done\r",
306
+ percentage, (nr+1), total);
307
}
308
}
309
switch (type) {
@@ -239,10 +311,11 @@ static void unpack_one(unsigned nr, unsigned total)
311
case OBJ_TREE:
312
case OBJ_BLOB:
313
case OBJ_TAG:
242
- unpack_non_delta_entry(type, size);
314
+ unpack_non_delta_entry(type, size, nr);
315
return;
316
case OBJ_REF_DELTA:
245
- unpack_delta_entry(size);
317
+ case OBJ_OFS_DELTA:
318
+ unpack_delta_entry(type, size, nr);
319
return;
320
default:
321
error("bad object type %d", type);
@@ -265,9 +338,10 @@ static void unpack_all(void)
338
die("unknown pack file version %d", ntohl(hdr->hdr_version));
339
fprintf(stderr, "Unpacking %d objects\n", nr_objects);
340
341
+ obj_list = xmalloc(nr_objects * sizeof(*obj_list));
342
use(sizeof(struct pack_header));
343
for (i = 0; i < nr_objects; i++)
270
- unpack_one(i+1, nr_objects);
344
+ unpack_one(i, nr_objects);
345
if (delta_list)
346
die("unresolved deltas left after unpacking");
347
}