pack-bitmap.c: avoid repeated `pack_pos_to_offset()` during reuse

When calling `try_partial_reuse()`, the (sole) caller from the function
`reuse_partial_packfile_from_bitmap_1()` has to translate its bit
position to a pack position.

In the MIDX bitmap case, the caller translates from the bit position, to
a position in the MIDX's pseudo-pack order (with `pack_pos_to_midx()`),
then get a pack offset (with `nth_midxed_offset()`) before finally
working backwards to get the pack position in the source pack by calling
`offset_to_pack_pos()`.

In the non-MIDX bitmap case, we can use the bit position as the pack
position directly (see the comment at the beginning of the
`reuse_partial_packfile_from_bitmap_1()` function for why).

In either case, the first thing that `try_partial_reuse()` does after
being called is determine the offset of the object at the given pack
position by calling `pack_pos_to_offset()`. But we already have that
information in the MIDX case!

Avoid re-computing that information by instead passing it in. In the
MIDX case, we already have that information stored. In the non-MIDX
case, the call to `pack_pos_to_offset()` moves from the function
`try_partial_reuse()` to its caller. In total, we'll save one call to
`pack_pos_to_offset()` when processing MIDX bitmaps.

(On my machine, there is a slight speed-up on the order of ~2ms, but it
is within the margin of error over 10 runs, so I think you'd have to
have a truly gigantic repository to confidently measure any significant
improvement here).

Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/pack-bitmap.c b/pack-bitmap.c
index 218d7ac2eb3d11fb595b63204d4b646b3593df14..9d9b8c4bfbcc86f79792c91696eda8b3d4d91d4f 100644 (file)
--- a/pack-bitmap.c
+++ b/pack-bitmap.c
@@ -2055,17 +2055,18 @@ static int try_partial_reuse(struct bitmap_index *bitmap_git,
                             struct bitmapped_pack *pack,
                             size_t bitmap_pos,
                             uint32_t pack_pos,
+                            off_t offset,
                             struct bitmap *reuse,
                             struct pack_window **w_curs)
 {
-       off_t offset, delta_obj_offset;
+       off_t delta_obj_offset;
        enum object_type type;
        unsigned long size;
 
        if (pack_pos >= pack->p->num_objects)
                return -1; /* not actually in the pack */
 
-       offset = delta_obj_offset = pack_pos_to_offset(pack->p, pack_pos);
+       delta_obj_offset = offset;
        type = unpack_object_header(pack->p, w_curs, &offset, &size);
        if (type < 0)
                return -1; /* broken packfile, punt */
@@ -2184,6 +2185,7 @@ static void reuse_partial_packfile_from_bitmap_1(struct bitmap_index *bitmap_git
                for (offset = 0; offset < BITS_IN_EWORD; offset++) {
                        size_t bit_pos;
                        uint32_t pack_pos;
+                       off_t ofs;
 
                        if (word >> offset == 0)
                                break;
@@ -2198,7 +2200,6 @@ static void reuse_partial_packfile_from_bitmap_1(struct bitmap_index *bitmap_git
 
                        if (bitmap_is_midx(bitmap_git)) {
                                uint32_t midx_pos;
-                               off_t ofs;
 
                                midx_pos = pack_pos_to_midx(bitmap_git->midx, bit_pos);
                                ofs = nth_midxed_offset(bitmap_git->midx, midx_pos);
@@ -2213,10 +2214,12 @@ static void reuse_partial_packfile_from_bitmap_1(struct bitmap_index *bitmap_git
                                        BUG("advanced beyond the end of pack %s (%"PRIuMAX" > %"PRIu32")",
                                            pack_basename(pack->p), (uintmax_t)pack_pos,
                                            pack->p->num_objects);
+
+                               ofs = pack_pos_to_offset(pack->p, pack_pos);
                        }
 
                        if (try_partial_reuse(bitmap_git, pack, bit_pos,
-                                             pack_pos, reuse, &w_curs) < 0) {
+                                             pack_pos, ofs, reuse, &w_curs) < 0) {
                                /*
                                 * try_partial_reuse indicated we couldn't reuse
                                 * any bits, so there is no point in trying more