repack-geometry: extract function to compute repacking split

We're about to add a second caller that wants to compute the repacking
split for a set of packfiles. Split out the function that computes this
split to prepare for that.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/repack-geometry.c b/repack-geometry.c
index b3e32cd07ec119d8b28776eaf4ca193df92cafe1..17e6652a91c7230e74aeb3f07e687beca50191a8 100644 (file)
--- a/repack-geometry.c
+++ b/repack-geometry.c
@@ -78,33 +78,32 @@ void pack_geometry_init(struct pack_geometry *geometry,
        strbuf_release(&buf);
 }
 
-void pack_geometry_split(struct pack_geometry *geometry)
+static uint32_t compute_pack_geometry_split(struct packed_git **pack, size_t pack_nr,
+                                           int split_factor)
 {
        uint32_t i;
        uint32_t split;
        off_t total_size = 0;
 
-       if (!geometry->pack_nr) {
-               geometry->split = geometry->pack_nr;
-               return;
-       }
+       if (!pack_nr)
+               return 0;
 
        /*
         * First, count the number of packs (in descending order of size) which
         * already form a geometric progression.
         */
-       for (i = geometry->pack_nr - 1; i > 0; i--) {
-               struct packed_git *ours = geometry->pack[i];
-               struct packed_git *prev = geometry->pack[i - 1];
+       for (i = pack_nr - 1; i > 0; i--) {
+               struct packed_git *ours = pack[i];
+               struct packed_git *prev = pack[i - 1];
 
-               if (unsigned_mult_overflows(geometry->split_factor,
+               if (unsigned_mult_overflows(split_factor,
                                            pack_geometry_weight(prev)))
                        die(_("pack %s too large to consider in geometric "
                              "progression"),
                            prev->pack_name);
 
                if (pack_geometry_weight(ours) <
-                   geometry->split_factor * pack_geometry_weight(prev))
+                   split_factor * pack_geometry_weight(prev))
                        break;
        }
 
@@ -130,21 +129,19 @@ void pack_geometry_split(struct pack_geometry *geometry)
         * the geometric progression.
         */
        for (i = 0; i < split; i++) {
-               struct packed_git *p = geometry->pack[i];
+               struct packed_git *p = pack[i];
 
                if (unsigned_add_overflows(total_size, pack_geometry_weight(p)))
                        die(_("pack %s too large to roll up"), p->pack_name);
                total_size += pack_geometry_weight(p);
        }
-       for (i = split; i < geometry->pack_nr; i++) {
-               struct packed_git *ours = geometry->pack[i];
+       for (i = split; i < pack_nr; i++) {
+               struct packed_git *ours = pack[i];
 
-               if (unsigned_mult_overflows(geometry->split_factor,
-                                           total_size))
+               if (unsigned_mult_overflows(split_factor, total_size))
                        die(_("pack %s too large to roll up"), ours->pack_name);
 
-               if (pack_geometry_weight(ours) <
-                   geometry->split_factor * total_size) {
+               if (pack_geometry_weight(ours) < split_factor * total_size) {
                        if (unsigned_add_overflows(total_size,
                                                   pack_geometry_weight(ours)))
                                die(_("pack %s too large to roll up"),
@@ -156,7 +153,13 @@ void pack_geometry_split(struct pack_geometry *geometry)
                        break;
        }
 
-       geometry->split = split;
+       return split;
+}
+
+void pack_geometry_split(struct pack_geometry *geometry)
+{
+       geometry->split = compute_pack_geometry_split(geometry->pack, geometry->pack_nr,
+                                                     geometry->split_factor);
 }
 
 struct packed_git *pack_geometry_preferred_pack(struct pack_geometry *geometry)