mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

midx: add repository to multi_pack_index struct

Browse Source 
The `multi_pack_index` struct represents the MIDX for a repository.
Here, we add a pointer to the repository in this struct, allowing direct
use of the repository variable without relying on the global
`the_repository` struct.

With this addition, we can determine the repository associated with a
`bitmap_index` struct. A `bitmap_index` points to either a `packed_git`
or a `multi_pack_index`, both of which have direct repository
references. To support this, we introduce a static helper function,
`bitmap_repo`, in `pack-bitmap.c`, which retrieves a repository given a
`bitmap_index`.

With this, we clear up all usages of `the_repository` within
`pack-bitmap.c` and also remove the `USE_THE_REPOSITORY_VARIABLE`
definition. Bringing us another step closer to remove all global
variable usage.

Although this change also opens up the potential to clean up `midx.c`,
doing so would require additional refactoring to pass the repository
struct to functions where the MIDX struct is created: a task better
suited for future patches.

Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Karthik Nayak
2024-12-03 15:44:03 +01:00
committed by Junio C Hamano
parent d284713bae
commit e106040722
3 changed files with 59 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
midx.c
View File

@ -131,6 +131,7 @@ static struct multi_pack_index *load_multi_pack_index_one(const char *object_dir
m->data = midx_map; m->data = midx_map;
m->data_len = midx_size; m->data_len = midx_size;
m->local = local; m->local = local;
m->repo = the_repository;
m->signature = get_be32(m->data); m->signature = get_be32(m->data);
if (m->signature != MIDX_SIGNATURE) if (m->signature != MIDX_SIGNATURE)

3
midx.h
View File

@ -71,6 +71,9 @@ struct multi_pack_index {
const char **pack_names; const char **pack_names;
struct packed_git **packs; struct packed_git **packs;
struct repository *repo;
char object_dir[FLEX_ARRAY]; char object_dir[FLEX_ARRAY];
}; };

90
pack-bitmap.c
View File

@ -1,5 +1,3 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h" #include "git-compat-util.h"
#include "commit.h" #include "commit.h"
#include "gettext.h" #include "gettext.h"
@ -177,12 +175,21 @@ static uint32_t bitmap_num_objects(struct bitmap_index *index)
return index->pack->num_objects; return index->pack->num_objects;
} }
static struct repository *bitmap_repo(struct bitmap_index *bitmap_git)
{
if (bitmap_is_midx(bitmap_git))
return bitmap_git->midx->repo;
return bitmap_git->pack->repo;
}
static int load_bitmap_header(struct bitmap_index *index) static int load_bitmap_header(struct bitmap_index *index)
{ {
struct bitmap_disk_header *header = (void *)index->map; struct bitmap_disk_header *header = (void *)index->map;
size_t header_size = sizeof(*header) - GIT_MAX_RAWSZ + the_hash_algo->rawsz; const struct git_hash_algo *hash_algo = bitmap_repo(index)->hash_algo;
if (index->map_size < header_size + the_hash_algo->rawsz) size_t header_size = sizeof(*header) - GIT_MAX_RAWSZ + hash_algo->rawsz;
if (index->map_size < header_size + hash_algo->rawsz)
return error(_("corrupted bitmap index (too small)")); return error(_("corrupted bitmap index (too small)"));
if (memcmp(header->magic, BITMAP_IDX_SIGNATURE, sizeof(BITMAP_IDX_SIGNATURE)) != 0) if (memcmp(header->magic, BITMAP_IDX_SIGNATURE, sizeof(BITMAP_IDX_SIGNATURE)) != 0)
@ -196,7 +203,7 @@ static int load_bitmap_header(struct bitmap_index *index)
{ {
uint32_t flags = ntohs(header->options); uint32_t flags = ntohs(header->options);
size_t cache_size = st_mult(bitmap_num_objects(index), sizeof(uint32_t)); size_t cache_size = st_mult(bitmap_num_objects(index), sizeof(uint32_t));
unsigned char *index_end = index->map + index->map_size - the_hash_algo->rawsz; unsigned char *index_end = index->map + index->map_size - hash_algo->rawsz;
if ((flags & BITMAP_OPT_FULL_DAG) == 0) if ((flags & BITMAP_OPT_FULL_DAG) == 0)
BUG("unsupported options for bitmap index file " BUG("unsupported options for bitmap index file "
@ -409,7 +416,7 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
if (bitmap_git->pack || bitmap_git->midx) { if (bitmap_git->pack || bitmap_git->midx) {
struct strbuf buf = STRBUF_INIT; struct strbuf buf = STRBUF_INIT;
get_midx_filename(&buf, midx->object_dir); get_midx_filename(&buf, midx->object_dir);
trace2_data_string("bitmap", the_repository, trace2_data_string("bitmap", bitmap_repo(bitmap_git),
"ignoring extra midx bitmap file", buf.buf); "ignoring extra midx bitmap file", buf.buf);
close(fd); close(fd);
strbuf_release(&buf); strbuf_release(&buf);
@ -427,7 +434,7 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
goto cleanup; goto cleanup;
if (!hasheq(get_midx_checksum(bitmap_git->midx), bitmap_git->checksum, if (!hasheq(get_midx_checksum(bitmap_git->midx), bitmap_git->checksum,
the_repository->hash_algo)) { bitmap_repo(bitmap_git)->hash_algo)) {
error(_("checksum doesn't match in MIDX and bitmap")); error(_("checksum doesn't match in MIDX and bitmap"));
goto cleanup; goto cleanup;
} }
@ -438,7 +445,9 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
} }
for (i = 0; i < bitmap_git->midx->num_packs; i++) { for (i = 0; i < bitmap_git->midx->num_packs; i++) {
if (prepare_midx_pack(the_repository, bitmap_git->midx, i)) { if (prepare_midx_pack(bitmap_repo(bitmap_git),
bitmap_git->midx,
i)) {
warning(_("could not open pack %s"), warning(_("could not open pack %s"),
bitmap_git->midx->pack_names[i]); bitmap_git->midx->pack_names[i]);
goto cleanup; goto cleanup;
@ -492,8 +501,9 @@ static int open_pack_bitmap_1(struct bitmap_index *bitmap_git, struct packed_git
} }
if (bitmap_git->pack || bitmap_git->midx) { if (bitmap_git->pack || bitmap_git->midx) {
trace2_data_string("bitmap", the_repository, trace2_data_string("bitmap", bitmap_repo(bitmap_git),
"ignoring extra bitmap file", packfile->pack_name); "ignoring extra bitmap file",
packfile->pack_name);
close(fd); close(fd);
return -1; return -1;
} }
@ -518,8 +528,8 @@ static int open_pack_bitmap_1(struct bitmap_index *bitmap_git, struct packed_git
return -1; return -1;
} }
trace2_data_string("bitmap", the_repository, "opened bitmap file", trace2_data_string("bitmap", bitmap_repo(bitmap_git),
packfile->pack_name); "opened bitmap file", packfile->pack_name);
return 0; return 0;
} }
@ -649,7 +659,7 @@ struct bitmap_index *prepare_bitmap_git(struct repository *r)
struct bitmap_index *prepare_midx_bitmap_git(struct multi_pack_index *midx) struct bitmap_index *prepare_midx_bitmap_git(struct multi_pack_index *midx)
{ {
struct repository *r = the_repository; struct repository *r = midx->repo;
struct bitmap_index *bitmap_git = xcalloc(1, sizeof(*bitmap_git)); struct bitmap_index *bitmap_git = xcalloc(1, sizeof(*bitmap_git));
if (!open_midx_bitmap_1(bitmap_git, midx) && !load_bitmap(r, bitmap_git)) if (!open_midx_bitmap_1(bitmap_git, midx) && !load_bitmap(r, bitmap_git))
@ -1213,6 +1223,7 @@ static struct bitmap *find_boundary_objects(struct bitmap_index *bitmap_git,
{ {
struct bitmap_boundary_cb cb; struct bitmap_boundary_cb cb;
struct object_list *root; struct object_list *root;
struct repository *repo;
unsigned int i; unsigned int i;
unsigned int tmp_blobs, tmp_trees, tmp_tags; unsigned int tmp_blobs, tmp_trees, tmp_tags;
int any_missing = 0; int any_missing = 0;
@ -1222,6 +1233,8 @@ static struct bitmap *find_boundary_objects(struct bitmap_index *bitmap_git,
cb.base = bitmap_new(); cb.base = bitmap_new();
object_array_init(&cb.boundary); object_array_init(&cb.boundary);
repo = bitmap_repo(bitmap_git);
revs->ignore_missing_links = 1; revs->ignore_missing_links = 1;
if (bitmap_git->pseudo_merges.nr) { if (bitmap_git->pseudo_merges.nr) {
@ -1280,19 +1293,19 @@ static struct bitmap *find_boundary_objects(struct bitmap_index *bitmap_git,
* revision walk to (a) OR in any bitmaps that are UNINTERESTING * revision walk to (a) OR in any bitmaps that are UNINTERESTING
* between the tips and boundary, and (b) record the boundary. * between the tips and boundary, and (b) record the boundary.
*/ */
trace2_region_enter("pack-bitmap", "boundary-prepare", the_repository); trace2_region_enter("pack-bitmap", "boundary-prepare", repo);
if (prepare_revision_walk(revs)) if (prepare_revision_walk(revs))
die("revision walk setup failed"); die("revision walk setup failed");
trace2_region_leave("pack-bitmap", "boundary-prepare", the_repository); trace2_region_leave("pack-bitmap", "boundary-prepare", repo);
trace2_region_enter("pack-bitmap", "boundary-traverse", the_repository); trace2_region_enter("pack-bitmap", "boundary-traverse", repo);
revs->boundary = 1; revs->boundary = 1;
traverse_commit_list_filtered(revs, traverse_commit_list_filtered(revs,
show_boundary_commit, show_boundary_commit,
show_boundary_object, show_boundary_object,
&cb, NULL); &cb, NULL);
revs->boundary = 0; revs->boundary = 0;
trace2_region_leave("pack-bitmap", "boundary-traverse", the_repository); trace2_region_leave("pack-bitmap", "boundary-traverse", repo);
revs->blob_objects = tmp_blobs; revs->blob_objects = tmp_blobs;
revs->tree_objects = tmp_trees; revs->tree_objects = tmp_trees;
@ -1304,7 +1317,7 @@ static struct bitmap *find_boundary_objects(struct bitmap_index *bitmap_git,
/* /*
* Then add the boundary commit(s) as fill-in traversal tips. * Then add the boundary commit(s) as fill-in traversal tips.
*/ */
trace2_region_enter("pack-bitmap", "boundary-fill-in", the_repository); trace2_region_enter("pack-bitmap", "boundary-fill-in", repo);
for (i = 0; i < cb.boundary.nr; i++) { for (i = 0; i < cb.boundary.nr; i++) {
struct object *obj = cb.boundary.objects[i].item; struct object *obj = cb.boundary.objects[i].item;
if (bitmap_walk_contains(bitmap_git, cb.base, &obj->oid)) if (bitmap_walk_contains(bitmap_git, cb.base, &obj->oid))
@ -1314,7 +1327,7 @@ static struct bitmap *find_boundary_objects(struct bitmap_index *bitmap_git,
} }
if (revs->pending.nr) if (revs->pending.nr)
cb.base = fill_in_bitmap(bitmap_git, revs, cb.base, NULL); cb.base = fill_in_bitmap(bitmap_git, revs, cb.base, NULL);
trace2_region_leave("pack-bitmap", "boundary-fill-in", the_repository); trace2_region_leave("pack-bitmap", "boundary-fill-in", repo);
cleanup: cleanup:
object_array_clear(&cb.boundary); object_array_clear(&cb.boundary);
@ -1718,7 +1731,8 @@ static unsigned long get_size_by_pos(struct bitmap_index *bitmap_git,
ofs = pack_pos_to_offset(pack, pos); ofs = pack_pos_to_offset(pack, pos);
} }
if (packed_object_info(the_repository, pack, ofs, &oi) < 0) { if (packed_object_info(bitmap_repo(bitmap_git), pack, ofs,
&oi) < 0) {
struct object_id oid; struct object_id oid;
nth_bitmap_object_oid(bitmap_git, &oid, nth_bitmap_object_oid(bitmap_git, &oid,
pack_pos_to_index(pack, pos)); pack_pos_to_index(pack, pos));
@ -1727,7 +1741,8 @@ static unsigned long get_size_by_pos(struct bitmap_index *bitmap_git,
} else { } else {
struct eindex *eindex = &bitmap_git->ext_index; struct eindex *eindex = &bitmap_git->ext_index;
struct object *obj = eindex->objects[pos - bitmap_num_objects(bitmap_git)]; struct object *obj = eindex->objects[pos - bitmap_num_objects(bitmap_git)];
if (oid_object_info_extended(the_repository, &obj->oid, &oi, 0) < 0) if (oid_object_info_extended(bitmap_repo(bitmap_git), &obj->oid,
&oi, 0) < 0)
die(_("unable to get size of %s"), oid_to_hex(&obj->oid)); die(_("unable to get size of %s"), oid_to_hex(&obj->oid));
} }
@ -1889,7 +1904,8 @@ static void filter_packed_objects_from_bitmap(struct bitmap_index *bitmap_git,
bitmap_unset(result, i); bitmap_unset(result, i);
for (i = 0; i < eindex->count; ++i) { for (i = 0; i < eindex->count; ++i) {
if (has_object_pack(the_repository, &eindex->objects[i]->oid)) if (has_object_pack(bitmap_repo(bitmap_git),
&eindex->objects[i]->oid))
bitmap_unset(result, objects_nr + i); bitmap_unset(result, objects_nr + i);
} }
} }
@ -1907,6 +1923,7 @@ struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs,
struct bitmap *haves_bitmap = NULL; struct bitmap *haves_bitmap = NULL;
struct bitmap_index *bitmap_git; struct bitmap_index *bitmap_git;
struct repository *repo;
/* /*
* We can't do pathspec limiting with bitmaps, because we don't know * We can't do pathspec limiting with bitmaps, because we don't know
@ -1980,18 +1997,20 @@ struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs,
if (!use_boundary_traversal) if (!use_boundary_traversal)
object_array_clear(&revs->pending); object_array_clear(&revs->pending);
repo = bitmap_repo(bitmap_git);
if (haves) { if (haves) {
if (use_boundary_traversal) { if (use_boundary_traversal) {
trace2_region_enter("pack-bitmap", "haves/boundary", the_repository); trace2_region_enter("pack-bitmap", "haves/boundary", repo);
haves_bitmap = find_boundary_objects(bitmap_git, revs, haves); haves_bitmap = find_boundary_objects(bitmap_git, revs, haves);
trace2_region_leave("pack-bitmap", "haves/boundary", the_repository); trace2_region_leave("pack-bitmap", "haves/boundary", repo);
} else { } else {
trace2_region_enter("pack-bitmap", "haves/classic", the_repository); trace2_region_enter("pack-bitmap", "haves/classic", repo);
revs->ignore_missing_links = 1; revs->ignore_missing_links = 1;
haves_bitmap = find_objects(bitmap_git, revs, haves, NULL); haves_bitmap = find_objects(bitmap_git, revs, haves, NULL);
reset_revision_walk(); reset_revision_walk();
revs->ignore_missing_links = 0; revs->ignore_missing_links = 0;
trace2_region_leave("pack-bitmap", "haves/classic", the_repository); trace2_region_leave("pack-bitmap", "haves/classic", repo);
} }
if (!haves_bitmap) if (!haves_bitmap)
@ -2025,17 +2044,17 @@ struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs,
object_list_free(&wants); object_list_free(&wants);
object_list_free(&haves); object_list_free(&haves);
trace2_data_intmax("bitmap", the_repository, "pseudo_merges_satisfied", trace2_data_intmax("bitmap", repo, "pseudo_merges_satisfied",
pseudo_merges_satisfied_nr); pseudo_merges_satisfied_nr);
trace2_data_intmax("bitmap", the_repository, "pseudo_merges_cascades", trace2_data_intmax("bitmap", repo, "pseudo_merges_cascades",
pseudo_merges_cascades_nr); pseudo_merges_cascades_nr);
trace2_data_intmax("bitmap", the_repository, "bitmap/hits", trace2_data_intmax("bitmap", repo, "bitmap/hits",
existing_bitmaps_hits_nr); existing_bitmaps_hits_nr);
trace2_data_intmax("bitmap", the_repository, "bitmap/misses", trace2_data_intmax("bitmap", repo, "bitmap/misses",
existing_bitmaps_misses_nr); existing_bitmaps_misses_nr);
trace2_data_intmax("bitmap", the_repository, "bitmap/roots_with_bitmap", trace2_data_intmax("bitmap", repo, "bitmap/roots_with_bitmap",
roots_with_bitmaps_nr); roots_with_bitmaps_nr);
trace2_data_intmax("bitmap", the_repository, "bitmap/roots_without_bitmap", trace2_data_intmax("bitmap", repo, "bitmap/roots_without_bitmap",
roots_without_bitmaps_nr); roots_without_bitmaps_nr);
return bitmap_git; return bitmap_git;
@ -2256,7 +2275,7 @@ void reuse_partial_packfile_from_bitmap(struct bitmap_index *bitmap_git,
struct bitmap **reuse_out, struct bitmap **reuse_out,
int multi_pack_reuse) int multi_pack_reuse)
{ {
struct repository *r = the_repository; struct repository *r = bitmap_repo(bitmap_git);
struct bitmapped_pack *packs = NULL; struct bitmapped_pack *packs = NULL;
struct bitmap *result = bitmap_git->result; struct bitmap *result = bitmap_git->result;
struct bitmap *reuse; struct bitmap *reuse;
@ -2792,7 +2811,7 @@ int rebuild_bitmap(const uint32_t *reposition,
uint32_t *create_bitmap_mapping(struct bitmap_index *bitmap_git, uint32_t *create_bitmap_mapping(struct bitmap_index *bitmap_git,
struct packing_data *mapping) struct packing_data *mapping)
{ {
struct repository *r = the_repository; struct repository *r = bitmap_repo(bitmap_git);
uint32_t i, num_objects; uint32_t i, num_objects;
uint32_t *reposition; uint32_t *reposition;
@ -2948,7 +2967,8 @@ static off_t get_disk_usage_for_extended(struct bitmap_index *bitmap_git)
st_add(bitmap_num_objects(bitmap_git), i))) st_add(bitmap_num_objects(bitmap_git), i)))
continue; continue;
if (oid_object_info_extended(the_repository, &obj->oid, &oi, 0) < 0) if (oid_object_info_extended(bitmap_repo(bitmap_git), &obj->oid,
&oi, 0) < 0)
die(_("unable to get disk usage of '%s'"), die(_("unable to get disk usage of '%s'"),
oid_to_hex(&obj->oid)); oid_to_hex(&obj->oid));