@matheusbsbs / matheus-bagliano / commits / 7cc8f97108

pack-objects: implement bitmap writing

This commit extends more the functionality of `pack-objects` by allowing it to write out a `.bitmap` index next to any written packs, together with the `.idx` index that currently gets written. If bitmap writing is enabled for a given repository (either by calling `pack-objects` with the `--write-bitmap-index` flag or by having `pack.writebitmaps` set to `true` in the config) and pack-objects is writing a packfile that would normally be indexed (i.e. not piping to stdout), we will attempt to write the corresponding bitmap index for the packfile. Bitmap index writing happens after the packfile and its index has been successfully written to disk (`finish_tmp_packfile`). The process is performed in several steps: 1. `bitmap_writer_set_checksum`: this call stores the partial checksum for the packfile being written; the checksum will be written in the resulting bitmap index to verify its integrity 2. `bitmap_writer_build_type_index`: this call uses the array of `struct object_entry` that has just been sorted when writing out the actual packfile index to disk to generate 4 type-index bitmaps (one for each object type). These bitmaps have their nth bit set if the given object is of the bitmap's type. E.g. the nth bit of the Commits bitmap will be 1 if the nth object in the packfile index is a commit. This is a very cheap operation because the bitmap writing code has access to the metadata stored in the `struct object_entry` array, and hence the real type for each object in the packfile. 3. `bitmap_writer_reuse_bitmaps`: if there exists an existing bitmap index for one of the packfiles we're trying to repack, this call will efficiently rebuild the existing bitmaps so they can be reused on the new index. All the existing bitmaps will be stored in a `reuse` hash table, and the commit selection phase will prioritize these when selecting, as they can be written directly to the new index without having to perform a revision walk to fill the bitmap. This can greatly speed up the repack of a repository that already has bitmaps. 4. `bitmap_writer_select_commits`: if bitmap writing is enabled for a given `pack-objects` run, the sequence of commits generated during the Counting Objects phase will be stored in an array. We then use that array to build up the list of selected commits. Writing a bitmap in the index for each object in the repository would be cost-prohibitive, so we use a simple heuristic to pick the commits that will be indexed with bitmaps. The current heuristics are a simplified version of JGit's original implementation. We select a higher density of commits depending on their age: the 100 most recent commits are always selected, after that we pick 1 commit of each 100, and the gap increases as the commits grow older. On top of that, we make sure that every single branch that has not been merged (all the tips that would be required from a clone) gets their own bitmap, and when selecting commits between a gap, we tend to prioritize the commit with the most parents. Do note that there is no right/wrong way to perform commit selection; different selection algorithms will result in different commits being selected, but there's no such thing as "missing a commit". The bitmap walker algorithm implemented in `prepare_bitmap_walk` is able to adapt to missing bitmaps by performing manual walks that complete the bitmap: the ideal selection algorithm, however, would select the commits that are more likely to be used as roots for a walk in the future (e.g. the tips of each branch, and so on) to ensure a bitmap for them is always available. 5. `bitmap_writer_build`: this is the computationally expensive part of bitmap generation. Based on the list of commits that were selected in the previous step, we perform several incremental walks to generate the bitmap for each commit. The walks begin from the oldest commit, and are built up incrementally for each branch. E.g. consider this dag where A, B, C, D, E, F are the selected commits, and a, b, c, e are a chunk of simplified history that will not receive bitmaps. A---a---B--b--C--c--D \ E--e--F We start by building the bitmap for A, using A as the root for a revision walk and marking all the objects that are reachable until the walk is over. Once this bitmap is stored, we reuse the bitmap walker to perform the walk for B, assuming that once we reach A again, the walk will be terminated because A has already been SEEN on the previous walk. This process is repeated for C, and D, but when we try to generate the bitmaps for E, we can reuse neither the current walk nor the bitmap we have generated so far. What we do now is resetting both the walk and clearing the bitmap, and performing the walk from scratch using E as the origin. This new walk, however, does not need to be completed. Once we hit B, we can lookup the bitmap we have already stored for that commit and OR it with the existing bitmap we've composed so far, allowing us to limit the walk early. After all the bitmaps have been generated, another iteration through the list of commits is performed to find the best XOR offsets for compression before writing them to disk. Because of the incremental nature of these bitmaps, XORing one of them with its predecesor results in a minimal "bitmap delta" most of the time. We can write this delta to the on-disk bitmap index, and then re-compose the original bitmaps by XORing them again when loaded. This is a phase very similar to pack-object's `find_delta` (using bitmaps instead of objects, of course), except the heuristics have been greatly simplified: we only check the 10 bitmaps before any given one to find best compressing one. This gives good results in practice, because there is locality in the ordering of the objects (and therefore bitmaps) in the packfile. 6. `bitmap_writer_finish`: the last step in the process is serializing to disk all the bitmap data that has been generated in the two previous steps. The bitmap is written to a tmp file and then moved atomically to its final destination, using the same process as `pack-write.c:write_idx_file`. Signed-off-by: Vicent Marti <tanoku@gmail.com> Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Vicent Marti committed Dec 21, 2013 at 09:00 UTC 7cc8f9710857ed69d34c696330f7fd0367a5a29c
8 files changed +711
Documentation/config.txt
+8
@@ -1864,6 +1864,14 @@ pack.useBitmaps::
1864 true. You should not generally need to turn this off unless
1865 you are debugging pack bitmaps.
1866
1867 +pack.writebitmaps::
1868 + When true, git will write a bitmap index when packing all
1869 + objects to disk (e.g., when `git repack -a` is run). This
1870 + index can speed up the "counting objects" phase of subsequent
1871 + packs created for clones and fetches, at the cost of some disk
1872 + space and extra time spent on the initial repack. Defaults to
1873 + false.
1874 +
1875 pager.<cmd>::
1876 If the value is boolean, turns on or off pagination of the
1877 output of a particular Git subcommand when writing to a tty.
Makefile
+1
@@ -839,6 +839,7 @@ LIB_OBJS += notes-merge.o
839 LIB_OBJS += notes-utils.o
840 LIB_OBJS += object.o
841 LIB_OBJS += pack-bitmap.o
842 +LIB_OBJS += pack-bitmap-write.o
843 LIB_OBJS += pack-check.o
844 LIB_OBJS += pack-objects.o
845 LIB_OBJS += pack-revindex.o
builtin/pack-objects.c
+53
@@ -63,6 +63,7 @@ static uint32_t reuse_packfile_objects;
63 static off_t reuse_packfile_offset;
64
65 static int use_bitmap_index = 1;
66 +static int write_bitmap_index;
67
68 static unsigned long delta_cache_size = 0;
69 static unsigned long max_delta_cache_size = 256 * 1024 * 1024;
@@ -76,6 +77,24 @@ static unsigned long window_memory_limit = 0;
77 static uint32_t written, written_delta;
78 static uint32_t reused, reused_delta;
79
80 +/*
81 + * Indexed commits
82 + */
83 +static struct commit **indexed_commits;
84 +static unsigned int indexed_commits_nr;
85 +static unsigned int indexed_commits_alloc;
86 +
87 +static void index_commit_for_bitmap(struct commit *commit)
88 +{
89 + if (indexed_commits_nr >= indexed_commits_alloc) {
90 + indexed_commits_alloc = (indexed_commits_alloc + 32) * 2;
91 + indexed_commits = xrealloc(indexed_commits,
92 + indexed_commits_alloc * sizeof(struct commit *));
93 + }
94 +
95 + indexed_commits[indexed_commits_nr++] = commit;
96 +}
97 +
98 static void *get_delta(struct object_entry *entry)
99 {
100 unsigned long size, base_size, delta_size;
@@ -812,9 +831,30 @@ static void write_pack_file(void)
831 if (sizeof(tmpname) <= strlen(base_name) + 50)
832 die("pack base name '%s' too long", base_name);
833 snprintf(tmpname, sizeof(tmpname), "%s-", base_name);
834 +
835 + if (write_bitmap_index) {
836 + bitmap_writer_set_checksum(sha1);
837 + bitmap_writer_build_type_index(written_list, nr_written);
838 + }
839 +
840 finish_tmp_packfile(tmpname, pack_tmp_name,
841 written_list, nr_written,
842 &pack_idx_opts, sha1);
843 +
844 + if (write_bitmap_index) {
845 + char *end_of_name_prefix = strrchr(tmpname, 0);
846 + sprintf(end_of_name_prefix, "%s.bitmap", sha1_to_hex(sha1));
847 +
848 + stop_progress(&progress_state);
849 +
850 + bitmap_writer_show_progress(progress);
851 + bitmap_writer_reuse_bitmaps(&to_pack);
852 + bitmap_writer_select_commits(indexed_commits, indexed_commits_nr, -1);
853 + bitmap_writer_build(&to_pack);
854 + bitmap_writer_finish(written_list, nr_written, tmpname);
855 + write_bitmap_index = 0;
856 + }
857 +
858 free(pack_tmp_name);
859 puts(sha1_to_hex(sha1));
860 }
@@ -2157,6 +2197,10 @@ static int git_pack_config(const char *k, const char *v, void *cb)
2197 cache_max_small_delta_size = git_config_int(k, v);
2198 return 0;
2199 }
2200 + if (!strcmp(k, "pack.writebitmaps")) {
2201 + write_bitmap_index = git_config_bool(k, v);
2202 + return 0;
2203 + }
2204 if (!strcmp(k, "pack.usebitmaps")) {
2205 use_bitmap_index = git_config_bool(k, v);
2206 return 0;
@@ -2219,6 +2263,9 @@ static void show_commit(struct commit *commit, void *data)
2263 {
2264 add_object_entry(commit->object.sha1, OBJ_COMMIT, NULL, 0);
2265 commit->object.flags |= OBJECT_ADDED;
2266 +
2267 + if (write_bitmap_index)
2268 + index_commit_for_bitmap(commit);
2269 }
2270
2271 static void show_object(struct object *obj,
@@ -2411,6 +2458,7 @@ static void get_object_list(int ac, const char **av)
2458 if (*line == '-') {
2459 if (!strcmp(line, "--not")) {
2460 flags ^= UNINTERESTING;
2461 + write_bitmap_index = 0;
2462 continue;
2463 }
2464 die("not a rev '%s'", line);
@@ -2553,6 +2601,8 @@ int cmd_pack_objects(int argc, const char **argv, const char *prefix)
2601 N_("do not hide commits by grafts"), 0),
2602 OPT_BOOL(0, "use-bitmap-index", &use_bitmap_index,
2603 N_("use a bitmap index if available to speed up counting objects")),
2604 + OPT_BOOL(0, "write-bitmap-index", &write_bitmap_index,
2605 + N_("write a bitmap index together with the pack index")),
2606 OPT_END(),
2607 };
2608
@@ -2622,6 +2672,9 @@ int cmd_pack_objects(int argc, const char **argv, const char *prefix)
2672 if (!use_internal_rev_list || !pack_to_stdout || is_repository_shallow())
2673 use_bitmap_index = 0;
2674
2675 + if (pack_to_stdout || !rev_list_all)
2676 + write_bitmap_index = 0;
2677 +
2678 if (progress && all_progress_implied)
2679 progress = 2;
2680
pack-bitmap-write.c new
+535
@@ -0,0 +1,535 @@
1 +#include "cache.h"
2 +#include "commit.h"
3 +#include "tag.h"
4 +#include "diff.h"
5 +#include "revision.h"
6 +#include "list-objects.h"
7 +#include "progress.h"
8 +#include "pack-revindex.h"
9 +#include "pack.h"
10 +#include "pack-bitmap.h"
11 +#include "sha1-lookup.h"
12 +#include "pack-objects.h"
13 +
14 +struct bitmapped_commit {
15 + struct commit *commit;
16 + struct ewah_bitmap *bitmap;
17 + struct ewah_bitmap *write_as;
18 + int flags;
19 + int xor_offset;
20 + uint32_t commit_pos;
21 +};
22 +
23 +struct bitmap_writer {
24 + struct ewah_bitmap *commits;
25 + struct ewah_bitmap *trees;
26 + struct ewah_bitmap *blobs;
27 + struct ewah_bitmap *tags;
28 +
29 + khash_sha1 *bitmaps;
30 + khash_sha1 *reused;
31 + struct packing_data *to_pack;
32 +
33 + struct bitmapped_commit *selected;
34 + unsigned int selected_nr, selected_alloc;
35 +
36 + struct progress *progress;
37 + int show_progress;
38 + unsigned char pack_checksum[20];
39 +};
40 +
41 +static struct bitmap_writer writer;
42 +
43 +void bitmap_writer_show_progress(int show)
44 +{
45 + writer.show_progress = show;
46 +}
47 +
48 +/**
49 + * Build the initial type index for the packfile
50 + */
51 +void bitmap_writer_build_type_index(struct pack_idx_entry **index,
52 + uint32_t index_nr)
53 +{
54 + uint32_t i;
55 +
56 + writer.commits = ewah_new();
57 + writer.trees = ewah_new();
58 + writer.blobs = ewah_new();
59 + writer.tags = ewah_new();
60 +
61 + for (i = 0; i < index_nr; ++i) {
62 + struct object_entry *entry = (struct object_entry *)index[i];
63 + enum object_type real_type;
64 +
65 + entry->in_pack_pos = i;
66 +
67 + switch (entry->type) {
68 + case OBJ_COMMIT:
69 + case OBJ_TREE:
70 + case OBJ_BLOB:
71 + case OBJ_TAG:
72 + real_type = entry->type;
73 + break;
74 +
75 + default:
76 + real_type = sha1_object_info(entry->idx.sha1, NULL);
77 + break;
78 + }
79 +
80 + switch (real_type) {
81 + case OBJ_COMMIT:
82 + ewah_set(writer.commits, i);
83 + break;
84 +
85 + case OBJ_TREE:
86 + ewah_set(writer.trees, i);
87 + break;
88 +
89 + case OBJ_BLOB:
90 + ewah_set(writer.blobs, i);
91 + break;
92 +
93 + case OBJ_TAG:
94 + ewah_set(writer.tags, i);
95 + break;
96 +
97 + default:
98 + die("Missing type information for %s (%d/%d)",
99 + sha1_to_hex(entry->idx.sha1), real_type, entry->type);
100 + }
101 + }
102 +}
103 +
104 +/**
105 + * Compute the actual bitmaps
106 + */
107 +static struct object **seen_objects;
108 +static unsigned int seen_objects_nr, seen_objects_alloc;
109 +
110 +static inline void push_bitmapped_commit(struct commit *commit, struct ewah_bitmap *reused)
111 +{
112 + if (writer.selected_nr >= writer.selected_alloc) {
113 + writer.selected_alloc = (writer.selected_alloc + 32) * 2;
114 + writer.selected = xrealloc(writer.selected,
115 + writer.selected_alloc * sizeof(struct bitmapped_commit));
116 + }
117 +
118 + writer.selected[writer.selected_nr].commit = commit;
119 + writer.selected[writer.selected_nr].bitmap = reused;
120 + writer.selected[writer.selected_nr].flags = 0;
121 +
122 + writer.selected_nr++;
123 +}
124 +
125 +static inline void mark_as_seen(struct object *object)
126 +{
127 + ALLOC_GROW(seen_objects, seen_objects_nr + 1, seen_objects_alloc);
128 + seen_objects[seen_objects_nr++] = object;
129 +}
130 +
131 +static inline void reset_all_seen(void)
132 +{
133 + unsigned int i;
134 + for (i = 0; i < seen_objects_nr; ++i) {
135 + seen_objects[i]->flags &= ~(SEEN | ADDED | SHOWN);
136 + }
137 + seen_objects_nr = 0;
138 +}
139 +
140 +static uint32_t find_object_pos(const unsigned char *sha1)
141 +{
142 + struct object_entry *entry = packlist_find(writer.to_pack, sha1, NULL);
143 +
144 + if (!entry) {
145 + die("Failed to write bitmap index. Packfile doesn't have full closure "
146 + "(object %s is missing)", sha1_to_hex(sha1));
147 + }
148 +
149 + return entry->in_pack_pos;
150 +}
151 +
152 +static void show_object(struct object *object, const struct name_path *path,
153 + const char *last, void *data)
154 +{
155 + struct bitmap *base = data;
156 + bitmap_set(base, find_object_pos(object->sha1));
157 + mark_as_seen(object);
158 +}
159 +
160 +static void show_commit(struct commit *commit, void *data)
161 +{
162 + mark_as_seen((struct object *)commit);
163 +}
164 +
165 +static int
166 +add_to_include_set(struct bitmap *base, struct commit *commit)
167 +{
168 + khiter_t hash_pos;
169 + uint32_t bitmap_pos = find_object_pos(commit->object.sha1);
170 +
171 + if (bitmap_get(base, bitmap_pos))
172 + return 0;
173 +
174 + hash_pos = kh_get_sha1(writer.bitmaps, commit->object.sha1);
175 + if (hash_pos < kh_end(writer.bitmaps)) {
176 + struct bitmapped_commit *bc = kh_value(writer.bitmaps, hash_pos);
177 + bitmap_or_ewah(base, bc->bitmap);
178 + return 0;
179 + }
180 +
181 + bitmap_set(base, bitmap_pos);
182 + return 1;
183 +}
184 +
185 +static int
186 +should_include(struct commit *commit, void *_data)
187 +{
188 + struct bitmap *base = _data;
189 +
190 + if (!add_to_include_set(base, commit)) {
191 + struct commit_list *parent = commit->parents;
192 +
193 + mark_as_seen((struct object *)commit);
194 +
195 + while (parent) {
196 + parent->item->object.flags |= SEEN;
197 + mark_as_seen((struct object *)parent->item);
198 + parent = parent->next;
199 + }
200 +
201 + return 0;
202 + }
203 +
204 + return 1;
205 +}
206 +
207 +static void compute_xor_offsets(void)
208 +{
209 + static const int MAX_XOR_OFFSET_SEARCH = 10;
210 +
211 + int i, next = 0;
212 +
213 + while (next < writer.selected_nr) {
214 + struct bitmapped_commit *stored = &writer.selected[next];
215 +
216 + int best_offset = 0;
217 + struct ewah_bitmap *best_bitmap = stored->bitmap;
218 + struct ewah_bitmap *test_xor;
219 +
220 + for (i = 1; i <= MAX_XOR_OFFSET_SEARCH; ++i) {
221 + int curr = next - i;
222 +
223 + if (curr < 0)
224 + break;
225 +
226 + test_xor = ewah_pool_new();
227 + ewah_xor(writer.selected[curr].bitmap, stored->bitmap, test_xor);
228 +
229 + if (test_xor->buffer_size < best_bitmap->buffer_size) {
230 + if (best_bitmap != stored->bitmap)
231 + ewah_pool_free(best_bitmap);
232 +
233 + best_bitmap = test_xor;
234 + best_offset = i;
235 + } else {
236 + ewah_pool_free(test_xor);
237 + }
238 + }
239 +
240 + stored->xor_offset = best_offset;
241 + stored->write_as = best_bitmap;
242 +
243 + next++;
244 + }
245 +}
246 +
247 +void bitmap_writer_build(struct packing_data *to_pack)
248 +{
249 + static const double REUSE_BITMAP_THRESHOLD = 0.2;
250 +
251 + int i, reuse_after, need_reset;
252 + struct bitmap *base = bitmap_new();
253 + struct rev_info revs;
254 +
255 + writer.bitmaps = kh_init_sha1();
256 + writer.to_pack = to_pack;
257 +
258 + if (writer.show_progress)
259 + writer.progress = start_progress("Building bitmaps", writer.selected_nr);
260 +
261 + init_revisions(&revs, NULL);
262 + revs.tag_objects = 1;
263 + revs.tree_objects = 1;
264 + revs.blob_objects = 1;
265 + revs.no_walk = 0;
266 +
267 + revs.include_check = should_include;
268 + reset_revision_walk();
269 +
270 + reuse_after = writer.selected_nr * REUSE_BITMAP_THRESHOLD;
271 + need_reset = 0;
272 +
273 + for (i = writer.selected_nr - 1; i >= 0; --i) {
274 + struct bitmapped_commit *stored;
275 + struct object *object;
276 +
277 + khiter_t hash_pos;
278 + int hash_ret;
279 +
280 + stored = &writer.selected[i];
281 + object = (struct object *)stored->commit;
282 +
283 + if (stored->bitmap == NULL) {
284 + if (i < writer.selected_nr - 1 &&
285 + (need_reset ||
286 + !in_merge_bases(writer.selected[i + 1].commit,
287 + stored->commit))) {
288 + bitmap_reset(base);
289 + reset_all_seen();
290 + }
291 +
292 + add_pending_object(&revs, object, "");
293 + revs.include_check_data = base;
294 +
295 + if (prepare_revision_walk(&revs))
296 + die("revision walk setup failed");
297 +
298 + traverse_commit_list(&revs, show_commit, show_object, base);
299 +
300 + revs.pending.nr = 0;
301 + revs.pending.alloc = 0;
302 + revs.pending.objects = NULL;
303 +
304 + stored->bitmap = bitmap_to_ewah(base);
305 + need_reset = 0;
306 + } else
307 + need_reset = 1;
308 +
309 + if (i >= reuse_after)
310 + stored->flags |= BITMAP_FLAG_REUSE;
311 +
312 + hash_pos = kh_put_sha1(writer.bitmaps, object->sha1, &hash_ret);
313 + if (hash_ret == 0)
314 + die("Duplicate entry when writing index: %s",
315 + sha1_to_hex(object->sha1));
316 +
317 + kh_value(writer.bitmaps, hash_pos) = stored;
318 + display_progress(writer.progress, writer.selected_nr - i);
319 + }
320 +
321 + bitmap_free(base);
322 + stop_progress(&writer.progress);
323 +
324 + compute_xor_offsets();
325 +}
326 +
327 +/**
328 + * Select the commits that will be bitmapped
329 + */
330 +static inline unsigned int next_commit_index(unsigned int idx)
331 +{
332 + static const unsigned int MIN_COMMITS = 100;
333 + static const unsigned int MAX_COMMITS = 5000;
334 +
335 + static const unsigned int MUST_REGION = 100;
336 + static const unsigned int MIN_REGION = 20000;
337 +
338 + unsigned int offset, next;
339 +
340 + if (idx <= MUST_REGION)
341 + return 0;
342 +
343 + if (idx <= MIN_REGION) {
344 + offset = idx - MUST_REGION;
345 + return (offset < MIN_COMMITS) ? offset : MIN_COMMITS;
346 + }
347 +
348 + offset = idx - MIN_REGION;
349 + next = (offset < MAX_COMMITS) ? offset : MAX_COMMITS;
350 +
351 + return (next > MIN_COMMITS) ? next : MIN_COMMITS;
352 +}
353 +
354 +static int date_compare(const void *_a, const void *_b)
355 +{
356 + struct commit *a = *(struct commit **)_a;
357 + struct commit *b = *(struct commit **)_b;
358 + return (long)b->date - (long)a->date;
359 +}
360 +
361 +void bitmap_writer_reuse_bitmaps(struct packing_data *to_pack)
362 +{
363 + if (prepare_bitmap_git() < 0)
364 + return;
365 +
366 + writer.reused = kh_init_sha1();
367 + rebuild_existing_bitmaps(to_pack, writer.reused, writer.show_progress);
368 +}
369 +
370 +static struct ewah_bitmap *find_reused_bitmap(const unsigned char *sha1)
371 +{
372 + khiter_t hash_pos;
373 +
374 + if (!writer.reused)
375 + return NULL;
376 +
377 + hash_pos = kh_get_sha1(writer.reused, sha1);
378 + if (hash_pos >= kh_end(writer.reused))
379 + return NULL;
380 +
381 + return kh_value(writer.reused, hash_pos);
382 +}
383 +
384 +void bitmap_writer_select_commits(struct commit **indexed_commits,
385 + unsigned int indexed_commits_nr,
386 + int max_bitmaps)
387 +{
388 + unsigned int i = 0, j, next;
389 +
390 + qsort(indexed_commits, indexed_commits_nr, sizeof(indexed_commits[0]),
391 + date_compare);
392 +
393 + if (writer.show_progress)
394 + writer.progress = start_progress("Selecting bitmap commits", 0);
395 +
396 + if (indexed_commits_nr < 100) {
397 + for (i = 0; i < indexed_commits_nr; ++i)
398 + push_bitmapped_commit(indexed_commits[i], NULL);
399 + return;
400 + }
401 +
402 + for (;;) {
403 + struct ewah_bitmap *reused_bitmap = NULL;
404 + struct commit *chosen = NULL;
405 +
406 + next = next_commit_index(i);
407 +
408 + if (i + next >= indexed_commits_nr)
409 + break;
410 +
411 + if (max_bitmaps > 0 && writer.selected_nr >= max_bitmaps) {
412 + writer.selected_nr = max_bitmaps;
413 + break;
414 + }
415 +
416 + if (next == 0) {
417 + chosen = indexed_commits[i];
418 + reused_bitmap = find_reused_bitmap(chosen->object.sha1);
419 + } else {
420 + chosen = indexed_commits[i + next];
421 +
422 + for (j = 0; j <= next; ++j) {
423 + struct commit *cm = indexed_commits[i + j];
424 +
425 + reused_bitmap = find_reused_bitmap(cm->object.sha1);
426 + if (reused_bitmap || (cm->object.flags & NEEDS_BITMAP) != 0) {
427 + chosen = cm;
428 + break;
429 + }
430 +
431 + if (cm->parents && cm->parents->next)
432 + chosen = cm;
433 + }
434 + }
435 +
436 + push_bitmapped_commit(chosen, reused_bitmap);
437 +
438 + i += next + 1;
439 + display_progress(writer.progress, i);
440 + }
441 +
442 + stop_progress(&writer.progress);
443 +}
444 +
445 +
446 +static int sha1write_ewah_helper(void *f, const void *buf, size_t len)
447 +{
448 + /* sha1write will die on error */
449 + sha1write(f, buf, len);
450 + return len;
451 +}
452 +
453 +/**
454 + * Write the bitmap index to disk
455 + */
456 +static inline void dump_bitmap(struct sha1file *f, struct ewah_bitmap *bitmap)
457 +{
458 + if (ewah_serialize_to(bitmap, sha1write_ewah_helper, f) < 0)
459 + die("Failed to write bitmap index");
460 +}
461 +
462 +static const unsigned char *sha1_access(size_t pos, void *table)
463 +{
464 + struct pack_idx_entry **index = table;
465 + return index[pos]->sha1;
466 +}
467 +
468 +static void write_selected_commits_v1(struct sha1file *f,
469 + struct pack_idx_entry **index,
470 + uint32_t index_nr)
471 +{
472 + int i;
473 +
474 + for (i = 0; i < writer.selected_nr; ++i) {
475 + struct bitmapped_commit *stored = &writer.selected[i];
476 + struct bitmap_disk_entry on_disk;
477 +
478 + int commit_pos =
479 + sha1_pos(stored->commit->object.sha1, index, index_nr, sha1_access);
480 +
481 + if (commit_pos < 0)
482 + die("BUG: trying to write commit not in index");
483 +
484 + on_disk.object_pos = htonl(commit_pos);
485 + on_disk.xor_offset = stored->xor_offset;
486 + on_disk.flags = stored->flags;
487 +
488 + sha1write(f, &on_disk, sizeof(on_disk));
489 + dump_bitmap(f, stored->write_as);
490 + }
491 +}
492 +
493 +void bitmap_writer_set_checksum(unsigned char *sha1)
494 +{
495 + hashcpy(writer.pack_checksum, sha1);
496 +}
497 +
498 +void bitmap_writer_finish(struct pack_idx_entry **index,
499 + uint32_t index_nr,
500 + const char *filename)
501 +{
502 + static char tmp_file[PATH_MAX];
503 + static uint16_t default_version = 1;
504 + static uint16_t flags = BITMAP_OPT_FULL_DAG;
505 + struct sha1file *f;
506 +
507 + struct bitmap_disk_header header;
508 +
509 + int fd = odb_mkstemp(tmp_file, sizeof(tmp_file), "pack/tmp_bitmap_XXXXXX");
510 +
511 + if (fd < 0)
512 + die_errno("unable to create '%s'", tmp_file);
513 + f = sha1fd(fd, tmp_file);
514 +
515 + memcpy(header.magic, BITMAP_IDX_SIGNATURE, sizeof(BITMAP_IDX_SIGNATURE));
516 + header.version = htons(default_version);
517 + header.options = htons(flags);
518 + header.entry_count = htonl(writer.selected_nr);
519 + memcpy(header.checksum, writer.pack_checksum, 20);
520 +
521 + sha1write(f, &header, sizeof(header));
522 + dump_bitmap(f, writer.commits);
523 + dump_bitmap(f, writer.trees);
524 + dump_bitmap(f, writer.blobs);
525 + dump_bitmap(f, writer.tags);
526 + write_selected_commits_v1(f, index, index_nr);
527 +
528 + sha1close(f, NULL, CSUM_FSYNC);
529 +
530 + if (adjust_shared_perm(tmp_file))
531 + die_errno("unable to make temporary bitmap file readable");
532 +
533 + if (rename(tmp_file, filename))
534 + die_errno("unable to rename temporary bitmap file to '%s'", filename);
535 +}
pack-bitmap.c
+92
@@ -968,3 +968,95 @@ void test_bitmap_walk(struct rev_info *revs)
968 else
969 fprintf(stderr, "Mismatch!\n");
970 }
971 +
972 +static int rebuild_bitmap(uint32_t *reposition,
973 + struct ewah_bitmap *source,
974 + struct bitmap *dest)
975 +{
976 + uint32_t pos = 0;
977 + struct ewah_iterator it;
978 + eword_t word;
979 +
980 + ewah_iterator_init(&it, source);
981 +
982 + while (ewah_iterator_next(&word, &it)) {
983 + uint32_t offset, bit_pos;
984 +
985 + for (offset = 0; offset < BITS_IN_WORD; ++offset) {
986 + if ((word >> offset) == 0)
987 + break;
988 +
989 + offset += ewah_bit_ctz64(word >> offset);
990 +
991 + bit_pos = reposition[pos + offset];
992 + if (bit_pos > 0)
993 + bitmap_set(dest, bit_pos - 1);
994 + else /* can't reuse, we don't have the object */
995 + return -1;
996 + }
997 +
998 + pos += BITS_IN_WORD;
999 + }
1000 + return 0;
1001 +}
1002 +
1003 +int rebuild_existing_bitmaps(struct packing_data *mapping,
1004 + khash_sha1 *reused_bitmaps,
1005 + int show_progress)
1006 +{
1007 + uint32_t i, num_objects;
1008 + uint32_t *reposition;
1009 + struct bitmap *rebuild;
1010 + struct stored_bitmap *stored;
1011 + struct progress *progress = NULL;
1012 +
1013 + khiter_t hash_pos;
1014 + int hash_ret;
1015 +
1016 + if (prepare_bitmap_git() < 0)
1017 + return -1;
1018 +
1019 + num_objects = bitmap_git.pack->num_objects;
1020 + reposition = xcalloc(num_objects, sizeof(uint32_t));
1021 +
1022 + for (i = 0; i < num_objects; ++i) {
1023 + const unsigned char *sha1;
1024 + struct revindex_entry *entry;
1025 + struct object_entry *oe;
1026 +
1027 + entry = &bitmap_git.reverse_index->revindex[i];
1028 + sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr);
1029 + oe = packlist_find(mapping, sha1, NULL);
1030 +
1031 + if (oe)
1032 + reposition[i] = oe->in_pack_pos + 1;
1033 + }
1034 +
1035 + rebuild = bitmap_new();
1036 + i = 0;
1037 +
1038 + if (show_progress)
1039 + progress = start_progress("Reusing bitmaps", 0);
1040 +
1041 + kh_foreach_value(bitmap_git.bitmaps, stored, {
1042 + if (stored->flags & BITMAP_FLAG_REUSE) {
1043 + if (!rebuild_bitmap(reposition,
1044 + lookup_stored_bitmap(stored),
1045 + rebuild)) {
1046 + hash_pos = kh_put_sha1(reused_bitmaps,
1047 + stored->sha1,
1048 + &hash_ret);
1049 + kh_value(reused_bitmaps, hash_pos) =
1050 + bitmap_to_ewah(rebuild);
1051 + }
1052 + bitmap_reset(rebuild);
1053 + display_progress(progress, ++i);
1054 + }
1055 + });
1056 +
1057 + stop_progress(&progress);
1058 +
1059 + free(reposition);
1060 + bitmap_free(rebuild);
1061 + return 0;
1062 +}
pack-bitmap.h
+19
@@ -3,6 +3,7 @@
3
4 #include "ewah/ewok.h"
5 #include "khash.h"
6 +#include "pack-objects.h"
7
8 struct bitmap_disk_entry {
9 uint32_t object_pos;
@@ -20,10 +21,16 @@ struct bitmap_disk_header {
21
22 static const char BITMAP_IDX_SIGNATURE[] = {'B', 'I', 'T', 'M'};
23
24 +#define NEEDS_BITMAP (1u<<22)
25 +
26 enum pack_bitmap_opts {
27 BITMAP_OPT_FULL_DAG = 1
28 };
29
30 +enum pack_bitmap_flags {
31 + BITMAP_FLAG_REUSE = 0x1
32 +};
33 +
34 typedef int (*show_reachable_fn)(
35 const unsigned char *sha1,
36 enum object_type type,
@@ -39,5 +46,17 @@ void test_bitmap_walk(struct rev_info *revs);
46 char *pack_bitmap_filename(struct packed_git *p);
47 int prepare_bitmap_walk(struct rev_info *revs);
48 int reuse_partial_packfile_from_bitmap(struct packed_git **packfile, uint32_t *entries, off_t *up_to);
49 +int rebuild_existing_bitmaps(struct packing_data *mapping, khash_sha1 *reused_bitmaps, int show_progress);
50 +
51 +void bitmap_writer_show_progress(int show);
52 +void bitmap_writer_set_checksum(unsigned char *sha1);
53 +void bitmap_writer_build_type_index(struct pack_idx_entry **index, uint32_t index_nr);
54 +void bitmap_writer_reuse_bitmaps(struct packing_data *to_pack);
55 +void bitmap_writer_select_commits(struct commit **indexed_commits,
56 + unsigned int indexed_commits_nr, int max_bitmaps);
57 +void bitmap_writer_build(struct packing_data *to_pack);
58 +void bitmap_writer_finish(struct pack_idx_entry **index,
59 + uint32_t index_nr,
60 + const char *filename);
61
62 #endif
pack-objects.h
+1
@@ -17,6 +17,7 @@ struct object_entry {
17 enum object_type type;
18 enum object_type in_pack_type; /* could be delta */
19 uint32_t hash; /* name hint hash */
20 + unsigned int in_pack_pos;
21 unsigned char in_pack_header_size;
22 unsigned preferred_base:1; /*
23 * we do not pack this, but is available
pack-write.c
+2
@@ -371,5 +371,7 @@ void finish_tmp_packfile(char *name_buffer,
371 if (rename(idx_tmp_name, name_buffer))
372 die_errno("unable to rename temporary index file");
373
374 + *end_of_name_prefix = '\0';
375 +
376 free((void *)idx_tmp_name);
377 }