kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

t/helper: add 'test-tool bitmap write' subcommand 

In f16eb1c091 (pseudo-merge: fix disk reads from find_pseudo_merge(),
2026-03-31), we noted that `apply_pseudo_merges_for_commit()` is never
triggered by the existing test suite, and that this bears further
investigation.

This patch is the first one to begin that investigation. The following
patches will expose and fix a variety of bugs in the implementation of
pseudo-merge bitmaps.

In order to do so, however, many of these tests require very precise
selection of which commits receive bitmaps and which do not. To date,
there isn't a standard approach to easily facilitate this. Address this
by introducing a `test-tool bitmap write` subcommand that writes a
bitmap for a given packfile, reading the set of commits which should
receive individual bitmaps from stdin like so:

    test-tool bitmap write <pack-basename> </path/to/commits.list

, where "<pack-basename>" is the filename for a specific packfile (e.g.,
"pack-abc123.pack"), and "/path/to/commits.list" is a list of commit
OIDs which will receive bitmaps.

The helper respects `bitmapPseudoMerge.*` configuration for creating
pseudo-merge bitmaps alongside the regular commit bitmaps.

Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
main
Taylor Blau 2026-05-11 20:46:48 -04:00 committed by Junio C Hamano
parent 8c9303b1ff
commit bc2f611569
2 changed files with 136 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
t/helper/test-bitmap.c
View File

@ -2,7 +2,10 @@

#include "test-tool.h"
#include "git-compat-util.h"
#include "hex.h"
#include "odb.h"
#include "pack-bitmap.h"
#include "pseudo-merge.h"
#include "setup.h"

static int bitmap_list_commits(void)
@ -35,6 +38,111 @@ static int bitmap_dump_pseudo_merge_objects(uint32_t n)
return test_bitmap_pseudo_merge_objects(the_repository, n);
}

static int add_packed_object(const struct object_id *oid,
struct packed_git *pack,
uint32_t pos,
void *_data)
{
struct packing_data *packed = _data;
struct object_entry *entry;
struct object_info oi = OBJECT_INFO_INIT;
enum object_type type;

oi.typep = &type;

entry = packlist_alloc(packed, oid);
entry->idx.offset = nth_packed_object_offset(pack, pos);
if (packed_object_info(pack, entry->idx.offset, &oi) < 0)
die("could not get type of object %s",
oid_to_hex(oid));
oe_set_type(entry, type);
oe_set_in_pack(packed, entry, pack);

return 0;
}

static int idx_oid_cmp(const void *va, const void *vb)
{
const struct pack_idx_entry *a = *(const struct pack_idx_entry **)va;
const struct pack_idx_entry *b = *(const struct pack_idx_entry **)vb;

return oidcmp(&a->oid, &b->oid);
}

static int bitmap_write(const char *basename)
{
struct packed_git *p = NULL;
struct packing_data packed = { 0 };
struct bitmap_writer writer;
struct pack_idx_entry **index;
struct strbuf buf = STRBUF_INIT;
uint32_t i;

prepare_repo_settings(the_repository);
repo_for_each_pack(the_repository, p) {
if (!strcmp(pack_basename(p), basename))
break;
}

if (!p)
die("could not find pack '%s'", basename);

if (open_pack_index(p))
die("cannot open pack index for '%s'", p->pack_name);

prepare_packing_data(the_repository, &packed);

for_each_object_in_pack(p, add_packed_object, &packed,
ODB_FOR_EACH_OBJECT_PACK_ORDER);

/*
* Build the index array now that data.packed.objects[] is
* fully allocated (packlist_alloc() may have reallocated it
* during the loop above).
*/
ALLOC_ARRAY(index, p->num_objects);
for (i = 0; i < p->num_objects; i++)
index[i] = &packed.objects[i].idx;

bitmap_writer_init(&writer, the_repository, &packed, NULL);
bitmap_writer_build_type_index(&writer, index);

while (strbuf_getline_lf(&buf, stdin) != EOF) {
struct object_id oid;
struct commit *c;

if (get_oid_hex(buf.buf, &oid))
die("invalid OID: %s", buf.buf);

c = lookup_commit(the_repository, &oid);
if (!c || repo_parse_commit(the_repository, c))
die("could not parse commit %s", buf.buf);

bitmap_writer_push_commit(&writer, c, 0);
}

select_pseudo_merges(&writer);
if (bitmap_writer_build(&writer) < 0)
die("failed to build bitmaps");

bitmap_writer_set_checksum(&writer, p->hash);

QSORT(index, p->num_objects, idx_oid_cmp);

strbuf_reset(&buf);
strbuf_addstr(&buf, p->pack_name);
strbuf_strip_suffix(&buf, ".pack");
strbuf_addstr(&buf, ".bitmap");
bitmap_writer_finish(&writer, index, buf.buf, 0);

bitmap_writer_free(&writer);
strbuf_release(&buf);
free(index);
clear_packing_data(&packed);

return 0;
}

int cmd__bitmap(int argc, const char **argv)
{
setup_git_directory();
@ -51,13 +159,16 @@ int cmd__bitmap(int argc, const char **argv)
return bitmap_dump_pseudo_merge_commits(atoi(argv[2]));
if (argc == 3 && !strcmp(argv[1], "dump-pseudo-merge-objects"))
return bitmap_dump_pseudo_merge_objects(atoi(argv[2]));
if (argc == 3 && !strcmp(argv[1], "write"))
return bitmap_write(argv[2]);

usage("\ttest-tool bitmap list-commits\n"
"\ttest-tool bitmap list-commits-with-offset\n"
"\ttest-tool bitmap dump-hashes\n"
"\ttest-tool bitmap dump-pseudo-merges\n"
"\ttest-tool bitmap dump-pseudo-merge-commits <n>\n"
"\ttest-tool bitmap dump-pseudo-merge-objects <n>");
"\ttest-tool bitmap dump-pseudo-merge-objects <n>\n"
"\ttest-tool bitmap write <pack-basename> < <commit-list>");

return -1;
}

24
t/t5310-pack-bitmaps.sh
View File

@ -648,4 +648,28 @@ test_expect_success 'truncated bitmap fails gracefully (lookup table)' '
test_grep corrupted.bitmap.index stderr
'

test_expect_success 'test-tool bitmap write determines bitmap selection' '
test_when_finished "rm -fr bitmap-write-helper" &&
git init bitmap-write-helper &&
(
cd bitmap-write-helper &&

test_commit_bulk 64 &&
git repack -ad &&

pack="$(ls .git/objects/pack/pack-*.pack)" &&

git rev-parse HEAD >in &&
test-tool bitmap write "$(basename $pack)" <in &&

test-tool bitmap list-commits >bitmaps.raw &&
sort bitmaps.raw >bitmaps &&
test_cmp in bitmaps &&

git rev-list --count --objects --use-bitmap-index HEAD >actual &&
git rev-list --count --objects HEAD >expect &&
test_cmp expect actual
)
'

test_done