From: Taylor Blau <me@ttaylorr.com> To: git@vger.kernel.org Cc: peff@peff.net, dstolee@microsoft.com, gitster@pobox.com, jonathantanmy@google.com Subject: [PATCH v4 14/25] pack-bitmap: read multi-pack bitmaps Date: Tue, 24 Aug 2021 12:16:25 -0400 [thread overview] Message-ID: <a0d73eb3d3720b66d63077390f2eb0afb71b193d.1629821743.git.me@ttaylorr.com> (raw) In-Reply-To: <cover.1629821743.git.me@ttaylorr.com> This prepares the code in pack-bitmap to interpret the new multi-pack bitmaps described in Documentation/technical/bitmap-format.txt, which mostly involves converting bit positions to accommodate looking them up in a MIDX. Note that there are currently no writers who write multi-pack bitmaps, and that this will be implemented in the subsequent commit. Note also that get_midx_checksum() and get_midx_filename() are made non-static so they can be called from pack-bitmap.c. Signed-off-by: Taylor Blau <me@ttaylorr.com> --- builtin/pack-objects.c | 5 + midx.c | 4 +- midx.h | 2 + pack-bitmap-write.c | 2 +- pack-bitmap.c | 357 ++++++++++++++++++++++++++++++++++++----- pack-bitmap.h | 6 + packfile.c | 2 +- 7 files changed, 336 insertions(+), 42 deletions(-) diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c index 8a523624a1..e11d3ac2e5 100644 --- a/builtin/pack-objects.c +++ b/builtin/pack-objects.c @@ -1124,6 +1124,11 @@ static void write_reused_pack(struct hashfile *f) break; offset += ewah_bit_ctz64(word >> offset); + /* + * Can use bit positions directly, even for MIDX + * bitmaps. See comment in try_partial_reuse() + * for why. + */ write_reused_pack_one(pos + offset, f, &w_curs); display_progress(progress_state, ++written); } diff --git a/midx.c b/midx.c index 3dacb31f9d..2dceaf9565 100644 --- a/midx.c +++ b/midx.c @@ -48,12 +48,12 @@ static uint8_t oid_version(void) } } -static const unsigned char *get_midx_checksum(struct multi_pack_index *m) +const unsigned char *get_midx_checksum(struct multi_pack_index *m) { return m->data + m->data_len - the_hash_algo->rawsz; } -static char *get_midx_filename(const char *object_dir) +char *get_midx_filename(const char *object_dir) { return xstrfmt("%s/pack/multi-pack-index", object_dir); } diff --git a/midx.h b/midx.h index 8684cf0fef..1172df1a71 100644 --- a/midx.h +++ b/midx.h @@ -42,6 +42,8 @@ struct multi_pack_index { #define MIDX_PROGRESS (1 << 0) #define MIDX_WRITE_REV_INDEX (1 << 1) +const unsigned char *get_midx_checksum(struct multi_pack_index *m); +char *get_midx_filename(const char *object_dir); char *get_midx_rev_filename(struct multi_pack_index *m); struct multi_pack_index *load_multi_pack_index(const char *object_dir, int local); diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c index 142fd0adb8..9c55c1531e 100644 --- a/pack-bitmap-write.c +++ b/pack-bitmap-write.c @@ -48,7 +48,7 @@ void bitmap_writer_show_progress(int show) } /** - * Build the initial type index for the packfile + * Build the initial type index for the packfile or multi-pack-index */ void bitmap_writer_build_type_index(struct packing_data *to_pack, struct pack_idx_entry **index, diff --git a/pack-bitmap.c b/pack-bitmap.c index 4e37f5d574..fa69ed7a6d 100644 --- a/pack-bitmap.c +++ b/pack-bitmap.c @@ -13,6 +13,7 @@ #include "repository.h" #include "object-store.h" #include "list-objects-filter-options.h" +#include "midx.h" #include "config.h" /* @@ -35,8 +36,15 @@ struct stored_bitmap { * the active bitmap index is the largest one. */ struct bitmap_index { - /* Packfile to which this bitmap index belongs to */ + /* + * The pack or multi-pack index (MIDX) that this bitmap index belongs + * to. + * + * Exactly one of these must be non-NULL; this specifies the object + * order used to interpret this bitmap. + */ struct packed_git *pack; + struct multi_pack_index *midx; /* * Mark the first `reuse_objects` in the packfile as reused: @@ -71,6 +79,9 @@ struct bitmap_index { /* If not NULL, this is a name-hash cache pointing into map. */ uint32_t *hashes; + /* The checksum of the packfile or MIDX; points into map. */ + const unsigned char *checksum; + /* * Extended index. * @@ -138,6 +149,8 @@ static struct ewah_bitmap *read_bitmap_1(struct bitmap_index *index) static uint32_t bitmap_num_objects(struct bitmap_index *index) { + if (index->midx) + return index->midx->num_objects; return index->pack->num_objects; } @@ -175,6 +188,7 @@ static int load_bitmap_header(struct bitmap_index *index) } index->entry_count = ntohl(header->entry_count); + index->checksum = header->checksum; index->map_pos += header_size; return 0; } @@ -227,6 +241,8 @@ static int nth_bitmap_object_oid(struct bitmap_index *index, struct object_id *oid, uint32_t n) { + if (index->midx) + return nth_midxed_object_oid(oid, index->midx, n) ? 0 : -1; return nth_packed_object_id(oid, index->pack, n); } @@ -274,7 +290,14 @@ static int load_bitmap_entries_v1(struct bitmap_index *index) return 0; } -static char *pack_bitmap_filename(struct packed_git *p) +char *midx_bitmap_filename(struct multi_pack_index *midx) +{ + return xstrfmt("%s-%s.bitmap", + get_midx_filename(midx->object_dir), + hash_to_hex(get_midx_checksum(midx))); +} + +char *pack_bitmap_filename(struct packed_git *p) { size_t len; @@ -283,6 +306,57 @@ static char *pack_bitmap_filename(struct packed_git *p) return xstrfmt("%.*s.bitmap", (int)len, p->pack_name); } +static int open_midx_bitmap_1(struct bitmap_index *bitmap_git, + struct multi_pack_index *midx) +{ + struct stat st; + char *idx_name = midx_bitmap_filename(midx); + int fd = git_open(idx_name); + + free(idx_name); + + if (fd < 0) + return -1; + + if (fstat(fd, &st)) { + close(fd); + return -1; + } + + if (bitmap_git->pack || bitmap_git->midx) { + /* ignore extra bitmap file; we can only handle one */ + warning("ignoring extra bitmap file: %s", + get_midx_filename(midx->object_dir)); + close(fd); + return -1; + } + + bitmap_git->midx = midx; + bitmap_git->map_size = xsize_t(st.st_size); + bitmap_git->map_pos = 0; + bitmap_git->map = xmmap(NULL, bitmap_git->map_size, PROT_READ, + MAP_PRIVATE, fd, 0); + close(fd); + + if (load_bitmap_header(bitmap_git) < 0) + goto cleanup; + + if (!hasheq(get_midx_checksum(bitmap_git->midx), bitmap_git->checksum)) + goto cleanup; + + if (load_midx_revindex(bitmap_git->midx) < 0) { + warning(_("multi-pack bitmap is missing required reverse index")); + goto cleanup; + } + return 0; + +cleanup: + munmap(bitmap_git->map, bitmap_git->map_size); + bitmap_git->map_size = 0; + bitmap_git->map = NULL; + return -1; +} + static int open_pack_bitmap_1(struct bitmap_index *bitmap_git, struct packed_git *packfile) { int fd; @@ -304,7 +378,8 @@ static int open_pack_bitmap_1(struct bitmap_index *bitmap_git, struct packed_git return -1; } - if (bitmap_git->pack) { + if (bitmap_git->pack || bitmap_git->midx) { + /* ignore extra bitmap file; we can only handle one */ warning("ignoring extra bitmap file: %s", packfile->pack_name); close(fd); return -1; @@ -331,13 +406,39 @@ static int open_pack_bitmap_1(struct bitmap_index *bitmap_git, struct packed_git return 0; } -static int load_pack_bitmap(struct bitmap_index *bitmap_git) +static int load_reverse_index(struct bitmap_index *bitmap_git) +{ + if (bitmap_is_midx(bitmap_git)) { + uint32_t i; + int ret; + + /* + * The multi-pack-index's .rev file is already loaded via + * open_pack_bitmap_1(). + * + * But we still need to open the individual pack .rev files, + * since we will need to make use of them in pack-objects. + */ + for (i = 0; i < bitmap_git->midx->num_packs; i++) { + if (prepare_midx_pack(the_repository, bitmap_git->midx, i)) + die(_("load_reverse_index: could not open pack")); + ret = load_pack_revindex(bitmap_git->midx->packs[i]); + if (ret) + return ret; + } + return 0; + } + return load_pack_revindex(bitmap_git->pack); +} + +static int load_bitmap(struct bitmap_index *bitmap_git) { assert(bitmap_git->map); bitmap_git->bitmaps = kh_init_oid_map(); bitmap_git->ext_index.positions = kh_init_oid_pos(); - if (load_pack_revindex(bitmap_git->pack)) + + if (load_reverse_index(bitmap_git)) goto failed; if (!(bitmap_git->commits = read_bitmap_1(bitmap_git)) || @@ -381,11 +482,47 @@ static int open_pack_bitmap(struct repository *r, return ret; } +static int open_midx_bitmap(struct repository *r, + struct bitmap_index *bitmap_git) +{ + struct multi_pack_index *midx; + + assert(!bitmap_git->map); + + for (midx = get_multi_pack_index(r); midx; midx = midx->next) { + if (!open_midx_bitmap_1(bitmap_git, midx)) + return 0; + } + return -1; +} + +static int open_bitmap(struct repository *r, + struct bitmap_index *bitmap_git) +{ + assert(!bitmap_git->map); + + if (!open_midx_bitmap(r, bitmap_git)) + return 0; + return open_pack_bitmap(r, bitmap_git); +} + struct bitmap_index *prepare_bitmap_git(struct repository *r) { struct bitmap_index *bitmap_git = xcalloc(1, sizeof(*bitmap_git)); - if (!open_pack_bitmap(r, bitmap_git) && !load_pack_bitmap(bitmap_git)) + if (!open_bitmap(r, bitmap_git) && !load_bitmap(bitmap_git)) + return bitmap_git; + + free_bitmap_index(bitmap_git); + return NULL; +} + +struct bitmap_index *prepare_midx_bitmap_git(struct repository *r, + struct multi_pack_index *midx) +{ + struct bitmap_index *bitmap_git = xcalloc(1, sizeof(*bitmap_git)); + + if (!open_midx_bitmap_1(bitmap_git, midx) && !load_bitmap(bitmap_git)) return bitmap_git; free_bitmap_index(bitmap_git); @@ -435,10 +572,26 @@ static inline int bitmap_position_packfile(struct bitmap_index *bitmap_git, return pos; } +static int bitmap_position_midx(struct bitmap_index *bitmap_git, + const struct object_id *oid) +{ + uint32_t want, got; + if (!bsearch_midx(oid, bitmap_git->midx, &want)) + return -1; + + if (midx_to_pack_pos(bitmap_git->midx, want, &got) < 0) + return -1; + return got; +} + static int bitmap_position(struct bitmap_index *bitmap_git, const struct object_id *oid) { - int pos = bitmap_position_packfile(bitmap_git, oid); + int pos; + if (bitmap_is_midx(bitmap_git)) + pos = bitmap_position_midx(bitmap_git, oid); + else + pos = bitmap_position_packfile(bitmap_git, oid); return (pos >= 0) ? pos : bitmap_position_extended(bitmap_git, oid); } @@ -749,6 +902,7 @@ static void show_objects_for_type( continue; for (offset = 0; offset < BITS_IN_EWORD; ++offset) { + struct packed_git *pack; struct object_id oid; uint32_t hash = 0, index_pos; off_t ofs; @@ -758,14 +912,28 @@ static void show_objects_for_type( offset += ewah_bit_ctz64(word >> offset); - index_pos = pack_pos_to_index(bitmap_git->pack, pos + offset); - ofs = pack_pos_to_offset(bitmap_git->pack, pos + offset); - nth_packed_object_id(&oid, bitmap_git->pack, index_pos); + if (bitmap_is_midx(bitmap_git)) { + struct multi_pack_index *m = bitmap_git->midx; + uint32_t pack_id; + + index_pos = pack_pos_to_midx(m, pos + offset); + ofs = nth_midxed_offset(m, index_pos); + nth_midxed_object_oid(&oid, m, index_pos); + + pack_id = nth_midxed_pack_int_id(m, index_pos); + pack = bitmap_git->midx->packs[pack_id]; + } else { + index_pos = pack_pos_to_index(bitmap_git->pack, pos + offset); + ofs = pack_pos_to_offset(bitmap_git->pack, pos + offset); + nth_bitmap_object_oid(bitmap_git, &oid, index_pos); + + pack = bitmap_git->pack; + } if (bitmap_git->hashes) hash = get_be32(bitmap_git->hashes + index_pos); - show_reach(&oid, object_type, 0, hash, bitmap_git->pack, ofs); + show_reach(&oid, object_type, 0, hash, pack, ofs); } } } @@ -777,8 +945,13 @@ static int in_bitmapped_pack(struct bitmap_index *bitmap_git, struct object *object = roots->item; roots = roots->next; - if (find_pack_entry_one(object->oid.hash, bitmap_git->pack) > 0) - return 1; + if (bitmap_is_midx(bitmap_git)) { + if (bsearch_midx(&object->oid, bitmap_git->midx, NULL)) + return 1; + } else { + if (find_pack_entry_one(object->oid.hash, bitmap_git->pack) > 0) + return 1; + } } return 0; @@ -865,14 +1038,26 @@ static void filter_bitmap_blob_none(struct bitmap_index *bitmap_git, static unsigned long get_size_by_pos(struct bitmap_index *bitmap_git, uint32_t pos) { - struct packed_git *pack = bitmap_git->pack; unsigned long size; struct object_info oi = OBJECT_INFO_INIT; oi.sizep = &size; if (pos < bitmap_num_objects(bitmap_git)) { - off_t ofs = pack_pos_to_offset(pack, pos); + struct packed_git *pack; + off_t ofs; + + if (bitmap_is_midx(bitmap_git)) { + uint32_t midx_pos = pack_pos_to_midx(bitmap_git->midx, pos); + uint32_t pack_id = nth_midxed_pack_int_id(bitmap_git->midx, midx_pos); + + pack = bitmap_git->midx->packs[pack_id]; + ofs = nth_midxed_offset(bitmap_git->midx, midx_pos); + } else { + pack = bitmap_git->pack; + ofs = pack_pos_to_offset(pack, pos); + } + if (packed_object_info(the_repository, pack, ofs, &oi) < 0) { struct object_id oid; nth_bitmap_object_oid(bitmap_git, &oid, @@ -1053,7 +1238,7 @@ struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs, /* try to open a bitmapped pack, but don't parse it yet * because we may not need to use it */ CALLOC_ARRAY(bitmap_git, 1); - if (open_pack_bitmap(revs->repo, bitmap_git) < 0) + if (open_bitmap(revs->repo, bitmap_git) < 0) goto cleanup; for (i = 0; i < revs->pending.nr; ++i) { @@ -1097,7 +1282,7 @@ struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs, * from disk. this is the point of no return; after this the rev_list * becomes invalidated and we must perform the revwalk through bitmaps */ - if (load_pack_bitmap(bitmap_git) < 0) + if (load_bitmap(bitmap_git) < 0) goto cleanup; object_array_clear(&revs->pending); @@ -1145,19 +1330,43 @@ struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs, * reused, but you can keep feeding bits. */ static int try_partial_reuse(struct bitmap_index *bitmap_git, + struct packed_git *pack, size_t pos, struct bitmap *reuse, struct pack_window **w_curs) { - off_t offset, header; + off_t offset, delta_obj_offset; enum object_type type; unsigned long size; - if (pos >= bitmap_num_objects(bitmap_git)) - return -1; /* not actually in the pack or MIDX */ + /* + * try_partial_reuse() is called either on (a) objects in the + * bitmapped pack (in the case of a single-pack bitmap) or (b) + * objects in the preferred pack of a multi-pack bitmap. + * Importantly, the latter can pretend as if only a single pack + * exists because: + * + * - The first pack->num_objects bits of a MIDX bitmap are + * reserved for the preferred pack, and + * + * - Ties due to duplicate objects are always resolved in + * favor of the preferred pack. + * + * Therefore we do not need to ever ask the MIDX for its copy of + * an object by OID, since it will always select it from the + * preferred pack. Likewise, the selected copy of the base + * object for any deltas will reside in the same pack. + * + * This means that we can reuse pos when looking up the bit in + * the reuse bitmap, too, since bits corresponding to the + * preferred pack precede all bits from other packs. + */ - offset = header = pack_pos_to_offset(bitmap_git->pack, pos); - type = unpack_object_header(bitmap_git->pack, w_curs, &offset, &size); + if (pos >= pack->num_objects) + return -1; /* not actually in the pack or MIDX preferred pack */ + + offset = delta_obj_offset = pack_pos_to_offset(pack, pos); + type = unpack_object_header(pack, w_curs, &offset, &size); if (type < 0) return -1; /* broken packfile, punt */ @@ -1173,11 +1382,11 @@ static int try_partial_reuse(struct bitmap_index *bitmap_git, * and the normal slow path will complain about it in * more detail. */ - base_offset = get_delta_base(bitmap_git->pack, w_curs, - &offset, type, header); + base_offset = get_delta_base(pack, w_curs, &offset, type, + delta_obj_offset); if (!base_offset) return 0; - if (offset_to_pack_pos(bitmap_git->pack, base_offset, &base_pos) < 0) + if (offset_to_pack_pos(pack, base_offset, &base_pos) < 0) return 0; /* @@ -1211,24 +1420,48 @@ static int try_partial_reuse(struct bitmap_index *bitmap_git, return 0; } +static uint32_t midx_preferred_pack(struct bitmap_index *bitmap_git) +{ + struct multi_pack_index *m = bitmap_git->midx; + if (!m) + BUG("midx_preferred_pack: requires non-empty MIDX"); + return nth_midxed_pack_int_id(m, pack_pos_to_midx(bitmap_git->midx, 0)); +} + int reuse_partial_packfile_from_bitmap(struct bitmap_index *bitmap_git, struct packed_git **packfile_out, uint32_t *entries, struct bitmap **reuse_out) { + struct packed_git *pack; struct bitmap *result = bitmap_git->result; struct bitmap *reuse; struct pack_window *w_curs = NULL; size_t i = 0; uint32_t offset; - uint32_t objects_nr = bitmap_num_objects(bitmap_git); + uint32_t objects_nr; assert(result); + load_reverse_index(bitmap_git); + + if (bitmap_is_midx(bitmap_git)) + pack = bitmap_git->midx->packs[midx_preferred_pack(bitmap_git)]; + else + pack = bitmap_git->pack; + objects_nr = pack->num_objects; + while (i < result->word_alloc && result->words[i] == (eword_t)~0) i++; - /* Don't mark objects not in the packfile */ + /* + * Don't mark objects not in the packfile or preferred pack. This bitmap + * marks objects eligible for reuse, but the pack-reuse code only + * understands how to reuse a single pack. Since the preferred pack is + * guaranteed to have all bases for its deltas (in a multi-pack bitmap), + * we use it instead of another pack. In single-pack bitmaps, the choice + * is made for us. + */ if (i > objects_nr / BITS_IN_EWORD) i = objects_nr / BITS_IN_EWORD; @@ -1244,8 +1477,8 @@ int reuse_partial_packfile_from_bitmap(struct bitmap_index *bitmap_git, break; offset += ewah_bit_ctz64(word >> offset); - if (try_partial_reuse(bitmap_git, pos + offset, reuse, - &w_curs) < 0) { + if (try_partial_reuse(bitmap_git, pack, pos + offset, + reuse, &w_curs) < 0) { /* * try_partial_reuse indicated we couldn't reuse * any bits, so there is no point in trying more @@ -1274,7 +1507,7 @@ int reuse_partial_packfile_from_bitmap(struct bitmap_index *bitmap_git, * need to be handled separately. */ bitmap_and_not(result, reuse); - *packfile_out = bitmap_git->pack; + *packfile_out = pack; *reuse_out = reuse; return 0; } @@ -1548,6 +1781,12 @@ uint32_t *create_bitmap_mapping(struct bitmap_index *bitmap_git, uint32_t i, num_objects; uint32_t *reposition; + if (!bitmap_is_midx(bitmap_git)) + load_reverse_index(bitmap_git); + else if (load_midx_revindex(bitmap_git->midx) < 0) + BUG("rebuild_existing_bitmaps: missing required rev-cache " + "extension"); + num_objects = bitmap_num_objects(bitmap_git); CALLOC_ARRAY(reposition, num_objects); @@ -1555,8 +1794,13 @@ uint32_t *create_bitmap_mapping(struct bitmap_index *bitmap_git, struct object_id oid; struct object_entry *oe; - nth_packed_object_id(&oid, bitmap_git->pack, - pack_pos_to_index(bitmap_git->pack, i)); + if (bitmap_is_midx(bitmap_git)) + nth_midxed_object_oid(&oid, + bitmap_git->midx, + pack_pos_to_midx(bitmap_git->midx, i)); + else + nth_packed_object_id(&oid, bitmap_git->pack, + pack_pos_to_index(bitmap_git->pack, i)); oe = packlist_find(mapping, &oid); if (oe) @@ -1582,6 +1826,19 @@ void free_bitmap_index(struct bitmap_index *b) free(b->ext_index.hashes); bitmap_free(b->result); bitmap_free(b->haves); + if (bitmap_is_midx(b)) { + /* + * Multi-pack bitmaps need to have resources associated with + * their on-disk reverse indexes unmapped so that stale .rev and + * .bitmap files can be removed. + * + * Unlike pack-based bitmaps, multi-pack bitmaps can be read and + * written in the same 'git multi-pack-index write --bitmap' + * process. Close resources so they can be removed safely on + * platforms like Windows. + */ + close_midx_revindex(b->midx); + } free(b); } @@ -1596,7 +1853,6 @@ static off_t get_disk_usage_for_type(struct bitmap_index *bitmap_git, enum object_type object_type) { struct bitmap *result = bitmap_git->result; - struct packed_git *pack = bitmap_git->pack; off_t total = 0; struct ewah_iterator it; eword_t filter; @@ -1613,15 +1869,35 @@ static off_t get_disk_usage_for_type(struct bitmap_index *bitmap_git, continue; for (offset = 0; offset < BITS_IN_EWORD; offset++) { - size_t pos; - if ((word >> offset) == 0) break; offset += ewah_bit_ctz64(word >> offset); - pos = base + offset; - total += pack_pos_to_offset(pack, pos + 1) - - pack_pos_to_offset(pack, pos); + + if (bitmap_is_midx(bitmap_git)) { + uint32_t pack_pos; + uint32_t midx_pos = pack_pos_to_midx(bitmap_git->midx, base + offset); + off_t offset = nth_midxed_offset(bitmap_git->midx, midx_pos); + + uint32_t pack_id = nth_midxed_pack_int_id(bitmap_git->midx, midx_pos); + struct packed_git *pack = bitmap_git->midx->packs[pack_id]; + + if (offset_to_pack_pos(pack, offset, &pack_pos) < 0) { + struct object_id oid; + nth_midxed_object_oid(&oid, bitmap_git->midx, midx_pos); + + die(_("could not find %s in pack %s at offset %"PRIuMAX), + oid_to_hex(&oid), + pack->pack_name, + (uintmax_t)offset); + } + + total += pack_pos_to_offset(pack, pack_pos + 1) - offset; + } else { + size_t pos = base + offset; + total += pack_pos_to_offset(bitmap_git->pack, pos + 1) - + pack_pos_to_offset(bitmap_git->pack, pos); + } } } @@ -1672,6 +1948,11 @@ off_t get_disk_usage_from_bitmap(struct bitmap_index *bitmap_git, return total; } +int bitmap_is_midx(struct bitmap_index *bitmap_git) +{ + return !!bitmap_git->midx; +} + const struct string_list *bitmap_preferred_tips(struct repository *r) { return repo_config_get_value_multi(r, "pack.preferbitmaptips"); diff --git a/pack-bitmap.h b/pack-bitmap.h index 52ea10de51..81664f933f 100644 --- a/pack-bitmap.h +++ b/pack-bitmap.h @@ -44,6 +44,8 @@ typedef int (*show_reachable_fn)( struct bitmap_index; struct bitmap_index *prepare_bitmap_git(struct repository *r); +struct bitmap_index *prepare_midx_bitmap_git(struct repository *r, + struct multi_pack_index *midx); void count_bitmap_commit_list(struct bitmap_index *, uint32_t *commits, uint32_t *trees, uint32_t *blobs, uint32_t *tags); void traverse_bitmap_commit_list(struct bitmap_index *, @@ -92,6 +94,10 @@ void bitmap_writer_finish(struct pack_idx_entry **index, uint32_t index_nr, const char *filename, uint16_t options); +char *midx_bitmap_filename(struct multi_pack_index *midx); +char *pack_bitmap_filename(struct packed_git *p); + +int bitmap_is_midx(struct bitmap_index *bitmap_git); const struct string_list *bitmap_preferred_tips(struct repository *r); int bitmap_is_preferred_refname(struct repository *r, const char *refname); diff --git a/packfile.c b/packfile.c index 9ef6d98292..371f5488cf 100644 --- a/packfile.c +++ b/packfile.c @@ -860,7 +860,7 @@ static void prepare_pack(const char *full_name, size_t full_name_len, if (!strcmp(file_name, "multi-pack-index")) return; if (starts_with(file_name, "multi-pack-index") && - ends_with(file_name, ".rev")) + (ends_with(file_name, ".bitmap") || ends_with(file_name, ".rev"))) return; if (ends_with(file_name, ".idx") || ends_with(file_name, ".rev") || -- 2.31.1.163.ga65ce7f831
next prev parent reply other threads:[~2021-08-24 16:16 UTC|newest] Thread overview: 273+ messages / expand[flat|nested] mbox.gz Atom feed top 2021-04-09 18:10 [PATCH 00/22] multi-pack reachability bitmaps Taylor Blau 2021-04-09 18:10 ` [PATCH 01/22] pack-bitmap.c: harden 'test_bitmap_walk()' to check type bitmaps Taylor Blau 2021-04-09 18:10 ` [PATCH 02/22] pack-bitmap-write.c: gracefully fail to write non-closed bitmaps Taylor Blau 2021-04-16 2:46 ` Jonathan Tan 2021-04-09 18:10 ` [PATCH 03/22] pack-bitmap-write.c: free existing bitmaps Taylor Blau 2021-04-09 18:10 ` [PATCH 04/22] Documentation: build 'technical/bitmap-format' by default Taylor Blau 2021-04-09 18:11 ` [PATCH 05/22] Documentation: describe MIDX-based bitmaps Taylor Blau 2021-04-09 18:11 ` [PATCH 06/22] midx: make a number of functions non-static Taylor Blau 2021-04-09 18:11 ` [PATCH 07/22] midx: clear auxiliary .rev after replacing the MIDX Taylor Blau 2021-04-09 18:11 ` [PATCH 08/22] midx: respect 'core.multiPackIndex' when writing Taylor Blau 2021-04-09 18:11 ` [PATCH 09/22] pack-bitmap.c: introduce 'bitmap_num_objects()' Taylor Blau 2021-04-09 18:11 ` [PATCH 10/22] pack-bitmap.c: introduce 'nth_bitmap_object_oid()' Taylor Blau 2021-04-09 18:11 ` [PATCH 11/22] pack-bitmap.c: introduce 'bitmap_is_preferred_refname()' Taylor Blau 2021-04-09 18:11 ` [PATCH 12/22] pack-bitmap: read multi-pack bitmaps Taylor Blau 2021-04-16 2:39 ` Jonathan Tan 2021-04-16 3:13 ` Taylor Blau 2021-04-09 18:11 ` [PATCH 13/22] pack-bitmap: write " Taylor Blau 2021-05-04 5:02 ` Jonathan Tan 2021-05-06 20:18 ` Taylor Blau 2021-05-06 22:00 ` Jonathan Tan 2021-04-09 18:11 ` [PATCH 14/22] t5310: move some tests to lib-bitmap.sh Taylor Blau 2021-04-09 18:11 ` [PATCH 15/22] t/helper/test-read-midx.c: add --checksum mode Taylor Blau 2021-04-09 18:12 ` [PATCH 16/22] t5326: test multi-pack bitmap behavior Taylor Blau 2021-05-04 17:51 ` Jonathan Tan 2021-04-09 18:12 ` [PATCH 17/22] t5310: disable GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP Taylor Blau 2021-04-09 18:12 ` [PATCH 18/22] t5319: don't write MIDX bitmaps in t5319 Taylor Blau 2021-04-09 18:12 ` [PATCH 19/22] t7700: update to work with MIDX bitmap test knob Taylor Blau 2021-04-09 18:12 ` [PATCH 20/22] midx: respect 'GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP' Taylor Blau 2021-04-09 18:12 ` [PATCH 21/22] p5310: extract full and partial bitmap tests Taylor Blau 2021-04-09 18:12 ` [PATCH 22/22] p5326: perf tests for MIDX bitmaps Taylor Blau 2021-05-04 18:00 ` Jonathan Tan 2021-05-05 0:55 ` Junio C Hamano 2021-06-21 22:24 ` [PATCH v2 00/24] multi-pack reachability bitmaps Taylor Blau 2021-06-21 22:24 ` [PATCH v2 01/24] pack-bitmap.c: harden 'test_bitmap_walk()' to check type bitmaps Taylor Blau 2021-06-24 23:02 ` Ævar Arnfjörð Bjarmason 2021-07-14 17:24 ` Taylor Blau 2021-07-21 9:45 ` Jeff King 2021-07-21 17:15 ` Taylor Blau 2021-06-21 22:25 ` [PATCH v2 02/24] pack-bitmap-write.c: gracefully fail to write non-closed bitmaps Taylor Blau 2021-06-24 23:23 ` Ævar Arnfjörð Bjarmason 2021-07-14 17:32 ` Taylor Blau 2021-07-14 18:44 ` Ævar Arnfjörð Bjarmason 2021-07-21 9:53 ` Jeff King 2021-07-21 9:50 ` Jeff King 2021-07-21 17:20 ` Taylor Blau 2021-07-23 7:37 ` Jeff King 2021-07-26 18:48 ` Taylor Blau 2021-07-27 17:11 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 03/24] pack-bitmap-write.c: free existing bitmaps Taylor Blau 2021-07-21 9:54 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 04/24] Documentation: build 'technical/bitmap-format' by default Taylor Blau 2021-06-24 23:35 ` Ævar Arnfjörð Bjarmason 2021-07-14 17:41 ` Taylor Blau 2021-07-14 22:58 ` Ævar Arnfjörð Bjarmason 2021-07-21 10:04 ` Jeff King 2021-07-21 10:10 ` Jeff King 2021-07-21 9:58 ` Jeff King 2021-07-21 10:08 ` Jeff King 2021-07-21 17:23 ` Taylor Blau 2021-07-23 7:39 ` Jeff King 2021-07-26 18:49 ` Taylor Blau 2021-06-21 22:25 ` [PATCH v2 05/24] Documentation: describe MIDX-based bitmaps Taylor Blau 2021-07-21 10:18 ` Jeff King 2021-07-21 17:53 ` Taylor Blau 2021-07-23 7:45 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 06/24] midx: make a number of functions non-static Taylor Blau 2021-06-24 23:42 ` Ævar Arnfjörð Bjarmason 2021-07-14 23:01 ` Taylor Blau 2021-06-21 22:25 ` [PATCH v2 07/24] midx: clear auxiliary .rev after replacing the MIDX Taylor Blau 2021-07-21 10:19 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 08/24] midx: respect 'core.multiPackIndex' when writing Taylor Blau 2021-06-24 23:43 ` Ævar Arnfjörð Bjarmason 2021-07-21 10:23 ` Jeff King 2021-07-21 19:22 ` Taylor Blau 2021-07-23 8:29 ` Jeff King 2021-07-26 18:59 ` Taylor Blau 2021-07-26 22:14 ` Taylor Blau 2021-07-27 17:29 ` Jeff King 2021-07-27 17:36 ` Taylor Blau 2021-07-27 17:42 ` Jeff King 2021-07-27 17:47 ` Taylor Blau 2021-07-27 17:55 ` Jeff King 2021-07-27 20:05 ` Taylor Blau 2021-07-28 17:46 ` Jeff King 2021-07-29 19:44 ` Taylor Blau 2021-08-12 19:59 ` Jeff King 2021-07-27 17:17 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 09/24] midx: infer preferred pack when not given one Taylor Blau 2021-07-21 10:34 ` Jeff King 2021-07-21 20:16 ` Taylor Blau 2021-07-23 8:50 ` Jeff King 2021-07-26 19:44 ` Taylor Blau 2021-06-21 22:25 ` [PATCH v2 10/24] pack-bitmap.c: introduce 'bitmap_num_objects()' Taylor Blau 2021-07-21 10:35 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 11/24] pack-bitmap.c: introduce 'nth_bitmap_object_oid()' Taylor Blau 2021-06-24 14:59 ` Taylor Blau 2021-07-21 10:37 ` Jeff King 2021-07-21 10:38 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 12/24] pack-bitmap.c: introduce 'bitmap_is_preferred_refname()' Taylor Blau 2021-07-21 10:39 ` Jeff King 2021-07-21 20:18 ` Taylor Blau 2021-06-21 22:25 ` [PATCH v2 13/24] pack-bitmap: read multi-pack bitmaps Taylor Blau 2021-07-21 11:32 ` Jeff King 2021-07-21 23:01 ` Taylor Blau 2021-07-23 9:40 ` Jeff King 2021-07-23 10:00 ` Jeff King 2021-07-26 20:36 ` Taylor Blau 2021-06-21 22:25 ` [PATCH v2 14/24] pack-bitmap: write " Taylor Blau 2021-06-24 23:45 ` Ævar Arnfjörð Bjarmason 2021-07-15 14:33 ` Taylor Blau 2021-07-21 12:09 ` Jeff King 2021-07-26 18:12 ` Taylor Blau 2021-07-26 18:23 ` Taylor Blau 2021-07-27 17:11 ` Jeff King 2021-07-27 20:33 ` Taylor Blau 2021-07-28 17:52 ` Jeff King 2021-07-29 19:33 ` Taylor Blau 2021-08-12 20:00 ` Jeff King 2021-06-21 22:25 ` [PATCH v2 15/24] t5310: move some tests to lib-bitmap.sh Taylor Blau 2021-06-21 22:25 ` [PATCH v2 16/24] t/helper/test-read-midx.c: add --checksum mode Taylor Blau 2021-06-21 22:25 ` [PATCH v2 17/24] t5326: test multi-pack bitmap behavior Taylor Blau 2021-06-21 22:25 ` [PATCH v2 18/24] t0410: disable GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP Taylor Blau 2021-06-21 22:25 ` [PATCH v2 19/24] t5310: " Taylor Blau 2021-06-21 22:25 ` [PATCH v2 20/24] t5319: don't write MIDX bitmaps in t5319 Taylor Blau 2021-06-21 22:25 ` [PATCH v2 21/24] t7700: update to work with MIDX bitmap test knob Taylor Blau 2021-06-21 22:25 ` [PATCH v2 22/24] midx: respect 'GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP' Taylor Blau 2021-06-25 0:03 ` Ævar Arnfjörð Bjarmason 2021-06-21 22:25 ` [PATCH v2 23/24] p5310: extract full and partial bitmap tests Taylor Blau 2021-06-21 22:26 ` [PATCH v2 24/24] p5326: perf tests for MIDX bitmaps Taylor Blau 2021-06-25 9:06 ` [PATCH v2 00/24] multi-pack reachability bitmaps Ævar Arnfjörð Bjarmason 2021-07-15 14:36 ` Taylor Blau 2021-07-21 12:12 ` Jeff King 2021-07-27 21:19 ` [PATCH v3 00/25] " Taylor Blau 2021-07-27 21:19 ` [PATCH v3 01/25] pack-bitmap.c: harden 'test_bitmap_walk()' to check type bitmaps Taylor Blau 2021-07-27 21:19 ` [PATCH v3 02/25] pack-bitmap-write.c: gracefully fail to write non-closed bitmaps Taylor Blau 2021-07-27 21:19 ` [PATCH v3 03/25] pack-bitmap-write.c: free existing bitmaps Taylor Blau 2021-07-27 21:19 ` [PATCH v3 04/25] Documentation: describe MIDX-based bitmaps Taylor Blau 2021-07-27 21:19 ` [PATCH v3 05/25] midx: clear auxiliary .rev after replacing the MIDX Taylor Blau 2021-07-27 21:19 ` [PATCH v3 06/25] midx: reject empty `--preferred-pack`'s Taylor Blau 2021-07-27 21:19 ` [PATCH v3 07/25] midx: infer preferred pack when not given one Taylor Blau 2021-07-27 21:19 ` [PATCH v3 08/25] midx: close linked MIDXs, avoid leaking memory Taylor Blau 2021-07-27 21:19 ` [PATCH v3 09/25] midx: avoid opening multiple MIDXs when writing Taylor Blau 2021-07-29 19:30 ` Taylor Blau 2021-08-12 20:15 ` Jeff King 2021-08-12 20:22 ` Jeff King 2021-08-12 21:20 ` Taylor Blau 2021-07-27 21:19 ` [PATCH v3 10/25] pack-bitmap.c: introduce 'bitmap_num_objects()' Taylor Blau 2021-07-27 21:19 ` [PATCH v3 11/25] pack-bitmap.c: introduce 'nth_bitmap_object_oid()' Taylor Blau 2021-07-27 21:19 ` [PATCH v3 12/25] pack-bitmap.c: introduce 'bitmap_is_preferred_refname()' Taylor Blau 2021-07-27 21:19 ` [PATCH v3 13/25] pack-bitmap.c: avoid redundant calls to try_partial_reuse Taylor Blau 2021-07-27 21:19 ` [PATCH v3 14/25] pack-bitmap: read multi-pack bitmaps Taylor Blau 2021-07-27 21:20 ` [PATCH v3 15/25] pack-bitmap: write " Taylor Blau 2021-07-27 21:20 ` [PATCH v3 16/25] t5310: move some tests to lib-bitmap.sh Taylor Blau 2021-08-12 20:25 ` Jeff King 2021-07-27 21:20 ` [PATCH v3 17/25] t/helper/test-read-midx.c: add --checksum mode Taylor Blau 2021-08-12 20:31 ` Jeff King 2021-08-12 21:31 ` Taylor Blau 2021-07-27 21:20 ` [PATCH v3 18/25] t5326: test multi-pack bitmap behavior Taylor Blau 2021-08-12 21:02 ` Jeff King 2021-08-12 21:07 ` Jeff King 2021-08-12 22:38 ` Taylor Blau 2021-08-12 23:23 ` Jeff King 2021-07-27 21:20 ` [PATCH v3 19/25] t0410: disable GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP Taylor Blau 2021-07-27 21:20 ` [PATCH v3 20/25] t5310: " Taylor Blau 2021-07-27 21:20 ` [PATCH v3 21/25] t5319: don't write MIDX bitmaps in t5319 Taylor Blau 2021-07-27 21:20 ` [PATCH v3 22/25] t7700: update to work with MIDX bitmap test knob Taylor Blau 2021-07-27 21:20 ` [PATCH v3 23/25] midx: respect 'GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP' Taylor Blau 2021-08-12 21:09 ` Jeff King 2021-07-27 21:20 ` [PATCH v3 24/25] p5310: extract full and partial bitmap tests Taylor Blau 2021-07-27 21:20 ` [PATCH v3 25/25] p5326: perf tests for MIDX bitmaps Taylor Blau 2021-08-12 21:18 ` Jeff King 2021-08-12 21:21 ` [PATCH v3 00/25] multi-pack reachability bitmaps Jeff King 2021-08-12 22:41 ` Taylor Blau 2021-08-24 16:15 ` [PATCH v4 " Taylor Blau 2021-08-24 16:15 ` [PATCH v4 01/25] pack-bitmap.c: harden 'test_bitmap_walk()' to check type bitmaps Taylor Blau 2021-08-24 16:15 ` [PATCH v4 02/25] pack-bitmap-write.c: gracefully fail to write non-closed bitmaps Taylor Blau 2021-08-24 16:15 ` [PATCH v4 03/25] pack-bitmap-write.c: free existing bitmaps Taylor Blau 2021-08-24 16:15 ` [PATCH v4 04/25] Documentation: describe MIDX-based bitmaps Taylor Blau 2021-08-24 16:16 ` [PATCH v4 05/25] midx: clear auxiliary .rev after replacing the MIDX Taylor Blau 2021-08-24 20:27 ` Junio C Hamano 2021-08-24 20:34 ` Taylor Blau 2021-08-24 21:12 ` Junio C Hamano 2021-08-24 21:24 ` Taylor Blau 2021-08-24 22:01 ` Taylor Blau 2021-08-24 22:04 ` Junio C Hamano 2021-08-24 22:06 ` Junio C Hamano 2021-08-24 22:10 ` Taylor Blau 2021-08-27 6:01 ` Junio C Hamano 2021-08-27 18:03 ` Taylor Blau 2021-08-29 22:56 ` Junio C Hamano 2021-08-30 0:07 ` Taylor Blau 2021-08-30 0:34 ` Junio C Hamano 2021-08-30 0:43 ` Taylor Blau 2021-08-30 22:10 ` brian m. carlson 2021-08-30 22:28 ` Junio C Hamano 2021-08-30 22:33 ` Taylor Blau 2021-08-31 5:19 ` Jeff King 2021-08-31 16:29 ` Junio C Hamano 2021-08-31 16:39 ` Taylor Blau 2021-08-31 17:44 ` Junio C Hamano 2021-08-31 18:48 ` Taylor Blau 2021-08-31 1:21 ` Derrick Stolee 2021-08-31 5:37 ` Jeff King 2021-08-31 16:33 ` Junio C Hamano 2021-08-31 16:43 ` Taylor Blau 2021-08-31 17:17 ` Derrick Stolee 2021-09-01 10:03 ` Jeff King 2021-08-24 16:16 ` [PATCH v4 06/25] midx: reject empty `--preferred-pack`'s Taylor Blau 2021-08-24 16:16 ` [PATCH v4 07/25] midx: infer preferred pack when not given one Taylor Blau 2021-08-24 16:16 ` [PATCH v4 08/25] midx: close linked MIDXs, avoid leaking memory Taylor Blau 2021-08-24 16:16 ` [PATCH v4 09/25] midx: avoid opening multiple MIDXs when writing Taylor Blau 2021-08-24 16:16 ` [PATCH v4 10/25] pack-bitmap.c: introduce 'bitmap_num_objects()' Taylor Blau 2021-08-24 16:16 ` [PATCH v4 11/25] pack-bitmap.c: introduce 'nth_bitmap_object_oid()' Taylor Blau 2021-08-24 16:16 ` [PATCH v4 12/25] pack-bitmap.c: introduce 'bitmap_is_preferred_refname()' Taylor Blau 2021-08-24 16:16 ` [PATCH v4 13/25] pack-bitmap.c: avoid redundant calls to try_partial_reuse Taylor Blau 2021-08-24 16:16 ` Taylor Blau [this message] 2021-08-24 16:16 ` [PATCH v4 15/25] pack-bitmap: write multi-pack bitmaps Taylor Blau 2021-08-24 16:16 ` [PATCH v4 16/25] t5310: move some tests to lib-bitmap.sh Taylor Blau 2021-08-24 16:16 ` [PATCH v4 17/25] t/helper/test-read-midx.c: add --checksum mode Taylor Blau 2021-08-24 16:16 ` [PATCH v4 18/25] t5326: test multi-pack bitmap behavior Taylor Blau 2021-08-24 16:16 ` [PATCH v4 19/25] t0410: disable GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP Taylor Blau 2021-08-24 16:16 ` [PATCH v4 20/25] t5310: " Taylor Blau 2021-08-24 16:16 ` [PATCH v4 21/25] t5319: don't write MIDX bitmaps in t5319 Taylor Blau 2021-08-24 16:16 ` [PATCH v4 22/25] t7700: update to work with MIDX bitmap test knob Taylor Blau 2021-08-24 16:16 ` [PATCH v4 23/25] midx: respect 'GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP' Taylor Blau 2021-08-24 16:16 ` [PATCH v4 24/25] p5310: extract full and partial bitmap tests Taylor Blau 2021-08-24 16:16 ` [PATCH v4 25/25] p5326: perf tests for MIDX bitmaps Taylor Blau 2021-08-25 0:28 ` [PATCH v4 00/25] multi-pack reachability bitmaps Jeff King 2021-08-25 2:10 ` Taylor Blau 2021-08-25 2:13 ` Taylor Blau 2021-08-25 7:36 ` Jeff King 2021-08-25 7:48 ` Johannes Berg 2021-08-26 18:49 ` Taylor Blau 2021-08-26 21:22 ` Taylor Blau 2021-08-27 21:30 ` Jeff King 2021-08-29 22:42 ` Junio C Hamano 2021-08-31 20:51 ` [PATCH v5 00/27] " Taylor Blau 2021-08-31 20:51 ` [PATCH v5 01/27] pack-bitmap.c: harden 'test_bitmap_walk()' to check type bitmaps Taylor Blau 2021-08-31 20:51 ` [PATCH v5 02/27] pack-bitmap-write.c: gracefully fail to write non-closed bitmaps Taylor Blau 2021-08-31 20:51 ` [PATCH v5 03/27] pack-bitmap-write.c: free existing bitmaps Taylor Blau 2021-08-31 20:51 ` [PATCH v5 04/27] Documentation: describe MIDX-based bitmaps Taylor Blau 2021-08-31 20:51 ` [PATCH v5 05/27] midx: disallow running outside of a repository Taylor Blau 2021-08-31 20:51 ` [PATCH v5 06/27] midx: fix `*.rev` cleanups with `--object-dir` Taylor Blau 2021-08-31 20:51 ` [PATCH v5 07/27] midx: clear auxiliary .rev after replacing the MIDX Taylor Blau 2021-08-31 20:52 ` [PATCH v5 08/27] midx: reject empty `--preferred-pack`'s Taylor Blau 2021-08-31 20:52 ` [PATCH v5 09/27] midx: infer preferred pack when not given one Taylor Blau 2021-08-31 20:52 ` [PATCH v5 10/27] midx: close linked MIDXs, avoid leaking memory Taylor Blau 2021-08-31 20:52 ` [PATCH v5 11/27] midx: avoid opening multiple MIDXs when writing Taylor Blau 2021-08-31 20:52 ` [PATCH v5 12/27] pack-bitmap.c: introduce 'bitmap_num_objects()' Taylor Blau 2021-08-31 20:52 ` [PATCH v5 13/27] pack-bitmap.c: introduce 'nth_bitmap_object_oid()' Taylor Blau 2021-08-31 20:52 ` [PATCH v5 14/27] pack-bitmap.c: introduce 'bitmap_is_preferred_refname()' Taylor Blau 2021-08-31 20:52 ` [PATCH v5 15/27] pack-bitmap.c: avoid redundant calls to try_partial_reuse Taylor Blau 2021-08-31 20:52 ` [PATCH v5 16/27] pack-bitmap: read multi-pack bitmaps Taylor Blau 2021-08-31 20:52 ` [PATCH v5 17/27] pack-bitmap: write " Taylor Blau 2021-08-31 20:52 ` [PATCH v5 18/27] t5310: move some tests to lib-bitmap.sh Taylor Blau 2021-08-31 20:52 ` [PATCH v5 19/27] t/helper/test-read-midx.c: add --checksum mode Taylor Blau 2021-08-31 20:52 ` [PATCH v5 20/27] t5326: test multi-pack bitmap behavior Taylor Blau 2021-08-31 20:52 ` [PATCH v5 21/27] t0410: disable GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP Taylor Blau 2021-08-31 20:52 ` [PATCH v5 22/27] t5310: " Taylor Blau 2021-08-31 20:52 ` [PATCH v5 23/27] t5319: don't write MIDX bitmaps in t5319 Taylor Blau 2021-08-31 20:52 ` [PATCH v5 24/27] t7700: update to work with MIDX bitmap test knob Taylor Blau 2021-08-31 20:52 ` [PATCH v5 25/27] midx: respect 'GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP' Taylor Blau 2021-08-31 20:52 ` [PATCH v5 26/27] p5310: extract full and partial bitmap tests Taylor Blau 2021-08-31 20:52 ` [PATCH v5 27/27] p5326: perf tests for MIDX bitmaps Taylor Blau 2021-09-01 18:07 ` [PATCH v5 00/27] multi-pack reachability bitmaps Junio C Hamano 2021-09-01 19:08 ` Taylor Blau 2021-09-01 19:23 ` Junio C Hamano 2021-09-01 20:34 ` Taylor Blau 2021-09-01 20:49 ` Junio C Hamano 2021-09-01 20:54 ` Taylor Blau 2021-09-02 9:40 ` Jeff King 2021-09-02 9:38 ` Jeff King 2021-09-02 9:45 ` Jeff King
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style List information: http://vger.kernel.org/majordomo-info.html * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=a0d73eb3d3720b66d63077390f2eb0afb71b193d.1629821743.git.me@ttaylorr.com \ --to=me@ttaylorr.com \ --cc=dstolee@microsoft.com \ --cc=git@vger.kernel.org \ --cc=gitster@pobox.com \ --cc=jonathantanmy@google.com \ --cc=peff@peff.net \ --subject='Re: [PATCH v4 14/25] pack-bitmap: read multi-pack bitmaps' \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: link
Code repositories for project(s) associated with this inbox: https://80x24.org/mirrors/git.git This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).