commit-reach: introduce struct paint_state with per-side counters

Add a paint_state struct for use by paint_down_to_common() that
wraps a prio_queue with per-side commit counters. Each non-stale
queued commit occupies exactly one counter bucket based on its
paint flags: PARENT1-only, PARENT2-only, or both sides (a pending
merge-base candidate).

The counters are maintained by paint_count_update() which adjusts
the appropriate bucket by a signed delta. An exhaustive switch on
the paint+stale bits documents all valid flag combinations in one
place.

Convert paint_down_to_common() to use paint_state. The loop now
drains the queue via paint_queue_get() which returns NULL when all
counters reach zero, replacing the old pointer-based termination
(max_nonstale). This is equivalent behavior -- both conditions
detect that no non-stale entries remain.

The existing nonstale_queue is left in place for ahead_behind().

Step counts (via trace2 from the previous commit) are identical
before and after this refactoring, confirming no behavioral change.

Signed-off-by: Kristofer Karlsson <krka@spotify.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/Documentation/technical/paint-down-to-common.adoc b/Documentation/technical/paint-down-to-common.adoc
index c10d5d2887d046b481eab8a3c68746a88cf98024..0f4e1892a52df70883e95a033dca99ef890b4057 100644 (file)
--- a/Documentation/technical/paint-down-to-common.adoc
+++ b/Documentation/technical/paint-down-to-common.adoc
@@ -88,15 +88,12 @@ re-enqueued is bounded by the number of flag transitions.
 Termination
 -----------
 
-The walk uses a `nonstale_queue` wrapper around `prio_queue` that
-tracks `max_nonstale`: the lowest-priority non-stale commit enqueued
-so far. Once that commit is dequeued, every remaining entry is known
-to be STALE and the loop terminates. Specifically, the main loop
+The walk tracks the number of commits of each type in the queue
+(PARENT1-only, PARENT2-only, pending merge-base). The main loop
 ends when one of the following conditions holds:
 
   1. The queue is empty.
-  2. `max_nonstale` has been dequeued, meaning the queue only contains
-     STALE entries.
+  2. The queue contains only stale entries.
 
 Stale entry condition
 ~~~~~~~~~~~~~~~~~~~~~

diff --git a/commit-reach.c b/commit-reach.c
index f6a438550b790279011463c169c32fbd269da052..bf102f5e287f4ec9ee8b0790fa1ede9fd1d5e9a5 100644 (file)
--- a/commit-reach.c
+++ b/commit-reach.c
@@ -97,6 +97,74 @@ static struct commit *nonstale_queue_get_dedup(struct nonstale_queue *queue)
        return commit;
 }
 
+/*
+ * Priority queue with per-side commit counters for paint_down_to_common().
+ * Each non-stale queued commit occupies exactly one bucket: PARENT1-only,
+ * PARENT2-only, or both (a pending merge-base candidate).
+ */
+struct paint_state {
+       struct prio_queue queue;
+       int p1_count;
+       int p2_count;
+       int pending_merge_bases;
+};
+
+static void paint_count_update(struct paint_state *state,
+                              unsigned flags, int delta)
+{
+       switch (flags & (PARENT1 | PARENT2 | STALE)) {
+       case PARENT1:
+               state->p1_count += delta;
+               break;
+
+       case PARENT2:
+               state->p2_count += delta;
+               break;
+
+       case PARENT1 | PARENT2:
+               state->pending_merge_bases += delta;
+               break;
+
+       case PARENT1 | PARENT2 | STALE:
+               break;
+
+       default:
+               BUG("unexpected paint state");
+       }
+}
+
+static void paint_queue_put(struct paint_state *state,
+                           struct commit *c, unsigned add_flags)
+{
+       unsigned old_flags = c->object.flags;
+       c->object.flags |= add_flags;
+
+       if (old_flags & ENQUEUED) {
+               paint_count_update(state, old_flags, -1);
+               paint_count_update(state, c->object.flags, 1);
+       } else {
+               c->object.flags |= ENQUEUED;
+               prio_queue_put(&state->queue, c);
+               paint_count_update(state, c->object.flags, 1);
+       }
+}
+
+static struct commit *paint_queue_get(struct paint_state *state)
+{
+       struct commit *commit;
+
+       if (!state->p1_count && !state->p2_count &&
+           !state->pending_merge_bases)
+               return NULL;
+
+       commit = prio_queue_get(&state->queue);
+       if (commit) {
+               commit->object.flags &= ~ENQUEUED;
+               paint_count_update(state, commit->object.flags, -1);
+       }
+       return commit;
+}
+
 /*
  * See Documentation/technical/paint-down-to-common.adoc
  *
@@ -109,31 +177,29 @@ static int paint_down_to_common(struct repository *r,
                                enum merge_base_flags mb_flags,
                                struct commit_list **result)
 {
-       struct nonstale_queue queue = {
-               { compare_commits_by_gen_then_commit_date }
+       struct paint_state state = {
+               .queue = { compare_commits_by_gen_then_commit_date }
        };
+       struct commit *commit;
        int i;
        int steps = 0;
        timestamp_t last_gen = GENERATION_NUMBER_INFINITY;
        struct commit_list **tail = result;
 
        if (!min_generation && !corrected_commit_dates_enabled(r))
-               queue.pq.compare = compare_commits_by_commit_date;
+               state.queue.compare = compare_commits_by_commit_date;
 
        one->object.flags |= PARENT1;
        if (!n) {
                commit_list_append(one, result);
                return 0;
        }
-       nonstale_queue_put_dedup(&queue, one);
+       paint_queue_put(&state, one, 0);
 
-       for (i = 0; i < n; i++) {
-               twos[i]->object.flags |= PARENT2;
-               nonstale_queue_put_dedup(&queue, twos[i]);
-       }
+       for (i = 0; i < n; i++)
+               paint_queue_put(&state, twos[i], PARENT2);
 
-       while (queue.max_nonstale) {
-               struct commit *commit = nonstale_queue_get_dedup(&queue);
+       while ((commit = paint_queue_get(&state))) {
                struct commit_list *parents;
                int flags;
                timestamp_t generation = commit_graph_generation(commit);
@@ -172,7 +238,7 @@ static int paint_down_to_common(struct repository *r,
                        if ((p->object.flags & flags) == flags)
                                continue;
                        if (repo_parse_commit(r, p)) {
-                               clear_nonstale_queue(&queue);
+                               clear_prio_queue(&state.queue);
                                commit_list_free(*result);
                                *result = NULL;
                                /*
@@ -187,12 +253,11 @@ static int paint_down_to_common(struct repository *r,
                                return error(_("could not parse commit %s"),
                                             oid_to_hex(&p->object.oid));
                        }
-                       p->object.flags |= flags;
-                       nonstale_queue_put_dedup(&queue, p);
+                       paint_queue_put(&state, p, flags);
                }
        }
 
-       clear_nonstale_queue(&queue);
+       clear_prio_queue(&state.queue);
        trace2_data_intmax("paint_down_to_common", r,
                           "steps", steps);
        commit_list_sort_by_date(result);