@matheusbsbs / matheus-bagliano / commits / 209c554ab4
Fork 0

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 }