?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] Modify git-rev-list to linearise the commit history in merge order.
[git/haiku.git] / mkdelta.c
blob1c10f1f143ea5fe202a6cf7eb3058e579ecc28c2
1 /*
2 * Deltafication of a GIT database.
3 *
4 * (C) 2005 Nicolas Pitre <nico@cam.org>
5 *
6 * This code is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11 #include "cache.h"
12 #include "delta.h"
13
14 static int replace_object(char *buf, unsigned long size, unsigned char *sha1)
15 {
16 char tmpfile[PATH_MAX];
17 int fd;
18
19 snprintf(tmpfile, sizeof(tmpfile), "%s/obj_XXXXXX", get_object_directory());
20 fd = mkstemp(tmpfile);
21 if (fd < 0)
22 return error("%s: %s\n", tmpfile, strerror(errno));
23 if (write(fd, buf, size) != size) {
24 perror("unable to write file");
25 close(fd);
26 unlink(tmpfile);
27 return -1;
28 }
29 fchmod(fd, 0444);
30 close(fd);
31 if (rename(tmpfile, sha1_file_name(sha1))) {
32 perror("unable to replace original object");
33 unlink(tmpfile);
34 return -1;
35 }
36 return 0;
37 }
38
39 static void *create_object(char *buf, unsigned long len, char *hdr, int hdrlen,
40 unsigned long *retsize)
41 {
42 char *compressed;
43 unsigned long size;
44 z_stream stream;
45
46 /* Set it up */
47 memset(&stream, 0, sizeof(stream));
48 deflateInit(&stream, Z_BEST_COMPRESSION);
49 size = deflateBound(&stream, len+hdrlen);
50 compressed = xmalloc(size);
51
52 /* Compress it */
53 stream.next_out = compressed;
54 stream.avail_out = size;
55
56 /* First header.. */
57 stream.next_in = hdr;
58 stream.avail_in = hdrlen;
59 while (deflate(&stream, 0) == Z_OK)
60 /* nothing */;
61
62 /* Then the data itself.. */
63 stream.next_in = buf;
64 stream.avail_in = len;
65 while (deflate(&stream, Z_FINISH) == Z_OK)
66 /* nothing */;
67 deflateEnd(&stream);
68 *retsize = stream.total_out;
69 return compressed;
70 }
71
72 static int restore_original_object(char *buf, unsigned long len,
73 char *type, unsigned char *sha1)
74 {
75 char hdr[50];
76 int hdrlen, ret;
77 void *compressed;
78 unsigned long size;
79
80 hdrlen = sprintf(hdr, "%s %lu", type, len)+1;
81 compressed = create_object(buf, len, hdr, hdrlen, &size);
82 ret = replace_object(compressed, size, sha1);
83 free(compressed);
84 return ret;
85 }
86
87 static void *create_delta_object(char *buf, unsigned long len,
88 unsigned char *sha1_ref, unsigned long *size)
89 {
90 char hdr[50];
91 int hdrlen;
92
93 /* Generate the header + sha1 of reference for delta */
94 hdrlen = sprintf(hdr, "delta %lu", len+20)+1;
95 memcpy(hdr + hdrlen, sha1_ref, 20);
96 hdrlen += 20;
97
98 return create_object(buf, len, hdr, hdrlen, size);
99 }
100
101 static void *get_buffer(unsigned char *sha1, char *type,
102 unsigned long *size, unsigned long *compsize)
103 {
104 unsigned long mapsize;
105 void *map = map_sha1_file(sha1, &mapsize);
106 if (map) {
107 void *buffer = unpack_sha1_file(map, mapsize, type, size);
108 munmap(map, mapsize);
109 if (compsize)
110 *compsize = mapsize;
111 if (buffer)
112 return buffer;
113 }
114 error("unable to get object %s", sha1_to_hex(sha1));
115 return NULL;
116 }
117
118 static void *expand_delta(void *delta, unsigned long *size, char *type,
119 unsigned int *depth, unsigned char **links)
120 {
121 void *buf = NULL;
122 unsigned int level = (*depth)++;
123 if (*size < 20) {
124 error("delta object is bad");
125 free(delta);
126 } else {
127 unsigned long ref_size;
128 void *ref = get_buffer(delta, type, &ref_size, NULL);
129 if (ref && !strcmp(type, "delta"))
130 ref = expand_delta(ref, &ref_size, type, depth, links);
131 else if (ref)
132 {
133 *links = xmalloc(*depth * 20);
134 }
135 if (ref) {
136 buf = patch_delta(ref, ref_size, delta+20, *size-20, size);
137 free(ref);
138 if (buf)
139 memcpy(*links + level*20, delta, 20);
140 else
141 free(*links);
142 }
143 free(delta);
144 }
145 return buf;
146 }
147
148 static char *mkdelta_usage =
149 "mkdelta [--max-depth=N] [--max-behind=N] <reference_sha1> <target_sha1> [<next_sha1> ...]";
150
151 struct delta {
152 unsigned char sha1[20]; /* object sha1 */
153 unsigned long size; /* object size */
154 void *buf; /* object content */
155 unsigned char *links; /* delta reference links */
156 unsigned int depth; /* delta depth */
157 };
158
159 int main(int argc, char **argv)
160 {
161 struct delta *ref, trg;
162 char ref_type[20], trg_type[20], *skip_reason;
163 void *best_buf;
164 unsigned long best_size, orig_size, orig_compsize;
165 unsigned int r, orig_ref, best_ref, nb_refs, next_ref, max_refs = 0;
166 unsigned int i, duplicate, skip_lvl, verbose = 0, quiet = 0;
167 unsigned int max_depth = -1;
168
169 for (i = 1; i < argc; i++) {
170 if (!strcmp(argv[i], "-v")) {
171 verbose = 1;
172 quiet = 0;
173 } else if (!strcmp(argv[i], "-q")) {
174 quiet = 1;
175 verbose = 0;
176 } else if (!strcmp(argv[i], "-d") && i+1 < argc) {
177 max_depth = atoi(argv[++i]);
178 } else if (!strncmp(argv[i], "--max-depth=", 12)) {
179 max_depth = atoi(argv[i]+12);
180 } else if (!strcmp(argv[i], "-b") && i+1 < argc) {
181 max_refs = atoi(argv[++i]);
182 } else if (!strncmp(argv[i], "--max-behind=", 13)) {
183 max_refs = atoi(argv[i]+13);
184 } else
185 break;
186 }
187
188 if (i + (max_depth != 0) >= argc)
189 usage(mkdelta_usage);
190
191 if (!max_refs || max_refs > argc - i)
192 max_refs = argc - i;
193 ref = xmalloc(max_refs * sizeof(*ref));
194 for (r = 0; r < max_refs; r++)
195 ref[r].buf = ref[r].links = NULL;
196 next_ref = nb_refs = 0;
197
198 do {
199 if (get_sha1(argv[i], trg.sha1))
200 die("bad sha1 %s", argv[i]);
201 trg.buf = get_buffer(trg.sha1, trg_type, &trg.size, &orig_compsize);
202 if (trg.buf && !trg.size) {
203 if (verbose)
204 printf("skip %s (object is empty)\n", argv[i]);
205 continue;
206 }
207 orig_size = trg.size;
208 orig_ref = -1;
209 trg.depth = 0;
210 trg.links = NULL;
211 if (trg.buf && !strcmp(trg_type, "delta")) {
212 for (r = 0; r < nb_refs; r++)
213 if (!memcmp(trg.buf, ref[r].sha1, 20))
214 break;
215 if (r < nb_refs) {
216 /* no need to reload the reference object */
217 trg.depth = ref[r].depth + 1;
218 trg.links = xmalloc(trg.depth*20);
219 memcpy(trg.links, trg.buf, 20);
220 memcpy(trg.links+20, ref[r].links, ref[r].depth*20);
221 trg.buf = patch_delta(ref[r].buf, ref[r].size,
222 trg.buf+20, trg.size-20,
223 &trg.size);
224 strcpy(trg_type, ref_type);
225 orig_ref = r;
226 } else {
227 trg.buf = expand_delta(trg.buf, &trg.size, trg_type,
228 &trg.depth, &trg.links);
229 }
230 }
231 if (!trg.buf)
232 die("unable to read target object %s", argv[i]);
233
234 if (!nb_refs) {
235 strcpy(ref_type, trg_type);
236 } else if (max_depth && strcmp(ref_type, trg_type)) {
237 die("type mismatch for object %s", argv[i]);
238 }
239
240 duplicate = 0;
241 best_buf = NULL;
242 best_size = -1;
243 best_ref = -1;
244 skip_lvl = 0;
245 skip_reason = NULL;
246 for (r = 0; max_depth && r < nb_refs; r++) {
247 void *delta_buf, *comp_buf;
248 unsigned long delta_size, comp_size;
249 unsigned int l;
250
251 duplicate = !memcmp(trg.sha1, ref[r].sha1, 20);
252 if (duplicate) {
253 skip_reason = "already seen";
254 break;
255 }
256 if (ref[r].depth >= max_depth) {
257 if (skip_lvl < 1) {
258 skip_reason = "exceeding max link depth";
259 skip_lvl = 1;
260 }
261 continue;
262 }
263 for (l = 0; l < ref[r].depth; l++)
264 if (!memcmp(trg.sha1, ref[r].links + l*20, 20))
265 break;
266 if (l != ref[r].depth) {
267 if (skip_lvl < 2) {
268 skip_reason = "would create a loop";
269 skip_lvl = 2;
270 }
271 continue;
272 }
273 if (trg.depth < max_depth && r == orig_ref) {
274 if (skip_lvl < 3) {
275 skip_reason = "delta already in place";
276 skip_lvl = 3;
277 }
278 continue;
279 }
280 delta_buf = diff_delta(ref[r].buf, ref[r].size,
281 trg.buf, trg.size, &delta_size);
282 if (!delta_buf)
283 die("out of memory");
284 if (trg.depth < max_depth &&
285 delta_size+20 >= orig_size) {
286 /* no need to even try to compress if original
287 object is smaller than this delta */
288 free(delta_buf);
289 if (skip_lvl < 4) {
290 skip_reason = "no size reduction";
291 skip_lvl = 4;
292 }
293 continue;
294 }
295 comp_buf = create_delta_object(delta_buf, delta_size,
296 ref[r].sha1, &comp_size);
297 if (!comp_buf)
298 die("out of memory");
299 free(delta_buf);
300 if (trg.depth < max_depth &&
301 comp_size >= orig_compsize) {
302 free(comp_buf);
303 if (skip_lvl < 5) {
304 skip_reason = "no size reduction";
305 skip_lvl = 5;
306 }
307 continue;
308 }
309 if ((comp_size < best_size) ||
310 (comp_size == best_size &&
311 ref[r].depth < ref[best_ref].depth)) {
312 free(best_buf);
313 best_buf = comp_buf;
314 best_size = comp_size;
315 best_ref = r;
316 }
317 }
318
319 if (best_buf) {
320 if (replace_object(best_buf, best_size, trg.sha1))
321 die("unable to write delta for %s", argv[i]);
322 free(best_buf);
323 free(trg.links);
324 trg.depth = ref[best_ref].depth + 1;
325 trg.links = xmalloc(trg.depth*20);
326 memcpy(trg.links, ref[best_ref].sha1, 20);
327 memcpy(trg.links+20, ref[best_ref].links, ref[best_ref].depth*20);
328 if (!quiet)
329 printf("delta %s (size=%ld.%02ld%% depth=%d dist=%d)\n",
330 argv[i], best_size*100 / orig_compsize,
331 (best_size*10000 / orig_compsize)%100,
332 trg.depth,
333 (next_ref - best_ref + max_refs)
334 % (max_refs + 1) + 1);
335 } else if (trg.depth > max_depth) {
336 if (restore_original_object(trg.buf, trg.size, trg_type, trg.sha1))
337 die("unable to restore %s", argv[i]);
338 if (!quiet)
339 printf("undelta %s (depth was %d)\n",
340 argv[i], trg.depth);
341 trg.depth = 0;
342 free(trg.links);
343 trg.links = NULL;
344 } else if (skip_reason && verbose) {
345 printf("skip %s (%s)\n", argv[i], skip_reason);
346 }
347
348 if (!duplicate) {
349 free(ref[next_ref].buf);
350 free(ref[next_ref].links);
351 ref[next_ref] = trg;
352 if (++next_ref > nb_refs)
353 nb_refs = next_ref;
354 if (next_ref == max_refs)
355 next_ref = 0;
356 } else {
357 free(trg.buf);
358 free(trg.links);
359 }
360 } while (++i < argc);
361
362 return 0;
363 }
Haiku port