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

midx-write.c: reduce argument count for get_sorted_entries()

Browse Source 
The function `midx-write.c::get_sorted_entries()` is responsible for
constructing the array of OIDs from a given list of packs which will
comprise the MIDX being written.

The singular call-site for this function looks something like:

    ctx.entries = get_sorted_entries(ctx.m, ctx.info, ctx.nr,
                                     &ctx.entries_nr,
                                     ctx.preferred_pack_idx);

This function has five formal arguments, all of which are members of the
shared `struct write_midx_context` used to track various pieces of
information about the MIDX being written.

The function `get_sorted_entries()` dates back to fe1ed56f5e (midx:
sort and deduplicate objects from packfiles, 2018-07-12), which came
shortly after 396f257018 (multi-pack-index: read packfile list,
2018-07-12). The latter patch introduced the `pack_list` structure,
which was a precursor to the structure we now know as
`write_midx_context` (c.f. 577dc49696 (midx: rename pack_info to
write_midx_context, 2021-02-18)).

At the time, `get_sorted_entries()` likely could have used the pack_list
structure introduced earlier in 396f257018, but understandably did not
since the structure only contained three fields (only two of which were
relevant to `get_sorted_entries()`) at the time.

Simplify the declaration of this function by taking a single pointer to
the whole `struct write_midx_context` instead of various members within
it. Since this function is now computing the entire result (populating
both `ctx->entries`, and `ctx->entries_nr`), rename it to something that
doesn't start with "get_" to make clear that this function has a
side-effect.

Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Taylor Blau
2024-05-29 18:55:23 -04:00
committed by Junio C Hamano
parent 23532be8e9
commit 3eac5e1ff1
1 changed files with 19 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
midx-write.c
View File

@ -299,21 +299,16 @@ static void midx_fanout_add_pack_fanout(struct midx_fanout *fanout,
* Copy only the de-duplicated entries (selected by most-recent modified time * Copy only the de-duplicated entries (selected by most-recent modified time
* of a packfile containing the object). * of a packfile containing the object).
*/ */
static struct pack_midx_entry *get_sorted_entries(struct multi_pack_index *m, static void compute_sorted_entries(struct write_midx_context *ctx)
struct pack_info *info,
uint32_t nr_packs,
size_t *nr_objects,
int preferred_pack)
{ {
uint32_t cur_fanout, cur_pack, cur_object; uint32_t cur_fanout, cur_pack, cur_object;
size_t alloc_objects, total_objects = 0; size_t alloc_objects, total_objects = 0;
struct midx_fanout fanout = { 0 }; struct midx_fanout fanout = { 0 };
struct pack_midx_entry *deduplicated_entries = NULL; uint32_t start_pack = ctx->m ? ctx->m->num_packs : 0;
uint32_t start_pack = m ? m->num_packs : 0;
for (cur_pack = start_pack; cur_pack < nr_packs; cur_pack++) for (cur_pack = start_pack; cur_pack < ctx->nr; cur_pack++)
total_objects = st_add(total_objects, total_objects = st_add(total_objects,
info[cur_pack].p->num_objects); ctx->info[cur_pack].p->num_objects);
/* /*
* As we de-duplicate by fanout value, we expect the fanout * As we de-duplicate by fanout value, we expect the fanout
@ -323,26 +318,26 @@ static struct pack_midx_entry *get_sorted_entries(struct multi_pack_index *m,
alloc_objects = fanout.alloc = total_objects > 3200 ? total_objects / 200 : 16; alloc_objects = fanout.alloc = total_objects > 3200 ? total_objects / 200 : 16;
ALLOC_ARRAY(fanout.entries, fanout.alloc); ALLOC_ARRAY(fanout.entries, fanout.alloc);
ALLOC_ARRAY(deduplicated_entries, alloc_objects); ALLOC_ARRAY(ctx->entries, alloc_objects);
*nr_objects = 0; ctx->entries_nr = 0;
for (cur_fanout = 0; cur_fanout < 256; cur_fanout++) { for (cur_fanout = 0; cur_fanout < 256; cur_fanout++) {
fanout.nr = 0; fanout.nr = 0;
if (m) if (ctx->m)
midx_fanout_add_midx_fanout(&fanout, m, cur_fanout, midx_fanout_add_midx_fanout(&fanout, ctx->m, cur_fanout,
preferred_pack); ctx->preferred_pack_idx);
for (cur_pack = start_pack; cur_pack < nr_packs; cur_pack++) { for (cur_pack = start_pack; cur_pack < ctx->nr; cur_pack++) {
int preferred = cur_pack == preferred_pack; int preferred = cur_pack == ctx->preferred_pack_idx;
midx_fanout_add_pack_fanout(&fanout, midx_fanout_add_pack_fanout(&fanout,
info, cur_pack, ctx->info, cur_pack,
preferred, cur_fanout); preferred, cur_fanout);
} }
if (-1 < preferred_pack && preferred_pack < start_pack) if (-1 < ctx->preferred_pack_idx && ctx->preferred_pack_idx < start_pack)
midx_fanout_add_pack_fanout(&fanout, info, midx_fanout_add_pack_fanout(&fanout, ctx->info,
preferred_pack, 1, ctx->preferred_pack_idx, 1,
cur_fanout); cur_fanout);
midx_fanout_sort(&fanout); midx_fanout_sort(&fanout);
@ -356,17 +351,16 @@ static struct pack_midx_entry *get_sorted_entries(struct multi_pack_index *m,
&fanout.entries[cur_object].oid)) &fanout.entries[cur_object].oid))
continue; continue;
ALLOC_GROW(deduplicated_entries, st_add(*nr_objects, 1), ALLOC_GROW(ctx->entries, st_add(ctx->entries_nr, 1),
alloc_objects); alloc_objects);
memcpy(&deduplicated_entries[*nr_objects], memcpy(&ctx->entries[ctx->entries_nr],
&fanout.entries[cur_object], &fanout.entries[cur_object],
sizeof(struct pack_midx_entry)); sizeof(struct pack_midx_entry));
(*nr_objects)++; ctx->entries_nr++;
} }
} }
free(fanout.entries); free(fanout.entries);
return deduplicated_entries;
} }
static int write_midx_pack_names(struct hashfile *f, void *data) static int write_midx_pack_names(struct hashfile *f, void *data)
@ -1054,8 +1048,7 @@ static int write_midx_internal(const char *object_dir,
} }
} }
ctx.entries = get_sorted_entries(ctx.m, ctx.info, ctx.nr, &ctx.entries_nr, compute_sorted_entries(&ctx);
ctx.preferred_pack_idx);
ctx.large_offsets_needed = 0; ctx.large_offsets_needed = 0;
for (i = 0; i < ctx.entries_nr; i++) { for (i = 0; i < ctx.entries_nr; i++) {