commit: move members graph_pos, generation to a slab

We remove members `graph_pos` and `generation` from the struct commit.
The default assignments in init_commit_node() are no longer valid,
which is fine as the slab helpers return appropriate default values and
the assignments are removed.

We will replace existing use of commit->generation and commit->graph_pos
by commit_graph_data_slab helpers using
`contrib/coccinelle/commit.cocci'.

Signed-off-by: Abhishek Kumar <abhishekkumar8222@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/alloc.c b/alloc.c
index 99fa934b32c4b6626988644982d03009e167b83e..957a0af3626432b0c9c2dd1301f20c4ff339a0a4 100644 (file)
--- a/alloc.c
+++ b/alloc.c
@@ -114,8 +114,6 @@ void init_commit_node(struct commit *c)
 {
        c->object.type = OBJ_COMMIT;
        c->index = alloc_commit_index();
-       c->graph_pos = COMMIT_NOT_FROM_GRAPH;
-       c->generation = GENERATION_NUMBER_INFINITY;
 }
 
 void *alloc_commit_node(struct repository *r)

diff --git a/blame.c b/blame.c
index da7e28800e7eb8c13b1200ed6207d2fe077ae66f..82fa16d6585b90e3635d87f6adc1e4856524f7d6 100644 (file)
--- a/blame.c
+++ b/blame.c
@@ -1272,7 +1272,7 @@ static int maybe_changed_path(struct repository *r,
        if (!bd)
                return 1;
 
-       if (origin->commit->generation == GENERATION_NUMBER_INFINITY)
+       if (commit_graph_generation(origin->commit) == GENERATION_NUMBER_INFINITY)
                return 1;
 
        filter = get_bloom_filter(r, origin->commit, 0);

diff --git a/bloom.c b/bloom.c
index 6c7611847ad05cb95103177ca00e7824f42b63c1..3062aafabad3dafb0b0c2baa16b685dbb4444916 100644 (file)
--- a/bloom.c
+++ b/bloom.c
@@ -34,14 +34,14 @@ static int load_bloom_filter_from_graph(struct commit_graph *g,
 {
        uint32_t lex_pos, start_index, end_index;
 
-       while (c->graph_pos < g->num_commits_in_base)
+       while (commit_graph_position(c) < g->num_commits_in_base)
                g = g->base_graph;
 
        /* The commit graph commit 'c' lives in doesn't carry bloom filters. */
        if (!g->chunk_bloom_indexes)
                return 0;
 
-       lex_pos = c->graph_pos - g->num_commits_in_base;
+       lex_pos = commit_graph_position(c) - g->num_commits_in_base;
 
        end_index = get_be32(g->chunk_bloom_indexes + 4 * lex_pos);
 
@@ -193,7 +193,7 @@ struct bloom_filter *get_bloom_filter(struct repository *r,
 
        if (!filter->data) {
                load_commit_graph_info(r, c);
-               if (c->graph_pos != COMMIT_NOT_FROM_GRAPH &&
+               if (commit_graph_position(c) != COMMIT_NOT_FROM_GRAPH &&
                        r->objects->commit_graph->chunk_bloom_indexes) {
                        if (load_bloom_filter_from_graph(r->objects->commit_graph, filter, c))
                                return filter;

diff --git a/commit-graph.c b/commit-graph.c
index 8ad7d202b24841faf239b8895b60a8cc264147ff..14cc7e931c65dfbf45c3912b780a51e9219b630a 100644 (file)
--- a/commit-graph.c
+++ b/commit-graph.c
@@ -145,9 +145,9 @@ static int commit_gen_cmp(const void *va, const void *vb)
        const struct commit *b = *(const struct commit **)vb;
 
        /* lower generation commits first */
-       if (a->generation < b->generation)
+       if (commit_graph_generation(a) < commit_graph_generation(b))
                return -1;
-       else if (a->generation > b->generation)
+       else if (commit_graph_generation(a) > commit_graph_generation(b))
                return 1;
 
        /* use date as a heuristic when generations are equal */
@@ -722,7 +722,7 @@ static struct commit_list **insert_parent_or_die(struct repository *r,
        c = lookup_commit(r, &oid);
        if (!c)
                die(_("could not find commit %s"), oid_to_hex(&oid));
-       c->graph_pos = pos;
+       commit_graph_data_at(c)->graph_pos = pos;
        return &commit_list_insert(c, pptr)->next;
 }
 
@@ -736,8 +736,8 @@ static void fill_commit_graph_info(struct commit *item, struct commit_graph *g,
 
        lex_index = pos - g->num_commits_in_base;
        commit_data = g->chunk_commit_data + GRAPH_DATA_WIDTH * lex_index;
-       item->graph_pos = pos;
-       item->generation = get_be32(commit_data + g->hash_len + 8) >> 2;
+       commit_graph_data_at(item)->graph_pos = pos;
+       commit_graph_data_at(item)->generation = get_be32(commit_data + g->hash_len + 8) >> 2;
 }
 
 static inline void set_commit_tree(struct commit *c, struct tree *t)
@@ -766,7 +766,7 @@ static int fill_commit_in_graph(struct repository *r,
         * Store the "full" position, but then use the
         * "local" position for the rest of the calculation.
         */
-       item->graph_pos = pos;
+       commit_graph_data_at(item)->graph_pos = pos;
        lex_index = pos - g->num_commits_in_base;
 
        commit_data = g->chunk_commit_data + (g->hash_len + 16) * lex_index;
@@ -779,7 +779,7 @@ static int fill_commit_in_graph(struct repository *r,
        date_low = get_be32(commit_data + g->hash_len + 12);
        item->date = (timestamp_t)((date_high << 32) | date_low);
 
-       item->generation = get_be32(commit_data + g->hash_len + 8) >> 2;
+       commit_graph_data_at(item)->generation = get_be32(commit_data + g->hash_len + 8) >> 2;
 
        pptr = &item->parents;
 
@@ -811,8 +811,8 @@ static int fill_commit_in_graph(struct repository *r,
 
 static int find_commit_in_graph(struct commit *item, struct commit_graph *g, uint32_t *pos)
 {
-       if (item->graph_pos != COMMIT_NOT_FROM_GRAPH) {
-               *pos = item->graph_pos;
+       if (commit_graph_position(item) != COMMIT_NOT_FROM_GRAPH) {
+               *pos = commit_graph_position(item);
                return 1;
        } else {
                struct commit_graph *cur_g = g;
@@ -868,11 +868,11 @@ static struct tree *load_tree_for_commit(struct repository *r,
        struct object_id oid;
        const unsigned char *commit_data;
 
-       while (c->graph_pos < g->num_commits_in_base)
+       while (commit_graph_position(c) < g->num_commits_in_base)
                g = g->base_graph;
 
        commit_data = g->chunk_commit_data +
-                       GRAPH_DATA_WIDTH * (c->graph_pos - g->num_commits_in_base);
+                       GRAPH_DATA_WIDTH * (commit_graph_position(c) - g->num_commits_in_base);
 
        hashcpy(oid.hash, commit_data);
        set_commit_tree(c, lookup_tree(r, &oid));
@@ -886,7 +886,7 @@ static struct tree *get_commit_tree_in_graph_one(struct repository *r,
 {
        if (c->maybe_tree)
                return c->maybe_tree;
-       if (c->graph_pos == COMMIT_NOT_FROM_GRAPH)
+       if (commit_graph_position(c) == COMMIT_NOT_FROM_GRAPH)
                BUG("get_commit_tree_in_graph_one called from non-commit-graph commit");
 
        return load_tree_for_commit(r, g, (struct commit *)c);
@@ -1271,7 +1271,7 @@ static void close_reachable(struct write_commit_graph_context *ctx)
                        continue;
                if (ctx->split) {
                        if ((!parse_commit(commit) &&
-                            commit->graph_pos == COMMIT_NOT_FROM_GRAPH) ||
+                            commit_graph_position(commit) == COMMIT_NOT_FROM_GRAPH) ||
                            flags == COMMIT_GRAPH_SPLIT_REPLACE)
                                add_missing_parents(ctx, commit);
                } else if (!parse_commit_no_graph(commit))
@@ -1516,7 +1516,7 @@ static uint32_t count_distinct_commits(struct write_commit_graph_context *ctx)
                        if (ctx->split) {
                                struct commit *c = lookup_commit(ctx->r, &ctx->oids.list[i]);
 
-                               if (!c || c->graph_pos != COMMIT_NOT_FROM_GRAPH)
+                               if (!c || commit_graph_position(c) != COMMIT_NOT_FROM_GRAPH)
                                        continue;
                        }
 
@@ -1550,7 +1550,7 @@ static void copy_oids_to_commits(struct write_commit_graph_context *ctx)
                ctx->commits.list[ctx->commits.nr] = lookup_commit(ctx->r, &ctx->oids.list[i]);
 
                if (ctx->split && flags != COMMIT_GRAPH_SPLIT_REPLACE &&
-                   ctx->commits.list[ctx->commits.nr]->graph_pos != COMMIT_NOT_FROM_GRAPH)
+                   commit_graph_position(ctx->commits.list[ctx->commits.nr]) != COMMIT_NOT_FROM_GRAPH)
                        continue;
 
                if (ctx->split && flags == COMMIT_GRAPH_SPLIT_REPLACE)
@@ -2337,8 +2337,8 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags)
                                             oid_to_hex(&graph_parents->item->object.oid),
                                             oid_to_hex(&odb_parents->item->object.oid));
 
-                       if (graph_parents->item->generation > max_generation)
-                               max_generation = graph_parents->item->generation;
+                       if (commit_graph_generation(graph_parents->item) > max_generation)
+                               max_generation = commit_graph_generation(graph_parents->item);
 
                        graph_parents = graph_parents->next;
                        odb_parents = odb_parents->next;
@@ -2348,7 +2348,7 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags)
                        graph_report(_("commit-graph parent list for commit %s terminates early"),
                                     oid_to_hex(&cur_oid));
 
-               if (!graph_commit->generation) {
+               if (!commit_graph_generation(graph_commit)) {
                        if (generation_zero == GENERATION_NUMBER_EXISTS)
                                graph_report(_("commit-graph has generation number zero for commit %s, but non-zero elsewhere"),
                                             oid_to_hex(&cur_oid));
@@ -2368,10 +2368,10 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags)
                if (max_generation == GENERATION_NUMBER_MAX)
                        max_generation--;
 
-               if (graph_commit->generation != max_generation + 1)
+               if (commit_graph_generation(graph_commit) != max_generation + 1)
                        graph_report(_("commit-graph generation for commit %s is %u != %u"),
                                     oid_to_hex(&cur_oid),
-                                    graph_commit->generation,
+                                    commit_graph_generation(graph_commit),
                                     max_generation + 1);
 
                if (graph_commit->date != odb_commit->date)

diff --git a/commit-reach.c b/commit-reach.c
index 4ca7e706a18ecf3c6cf862966b9d2f81d02bc964..3b2f863f5fa5d1da74492fd79e2244591680b2a2 100644 (file)
--- a/commit-reach.c
+++ b/commit-reach.c
@@ -59,13 +59,13 @@ static struct commit_list *paint_down_to_common(struct repository *r,
                struct commit_list *parents;
                int flags;
 
-               if (min_generation && commit->generation > last_gen)
+               if (min_generation && commit_graph_generation(commit) > last_gen)
                        BUG("bad generation skip %8x > %8x at %s",
-                           commit->generation, last_gen,
+                           commit_graph_generation(commit), last_gen,
                            oid_to_hex(&commit->object.oid));
-               last_gen = commit->generation;
+               last_gen = commit_graph_generation(commit);
 
-               if (commit->generation < min_generation)
+               if (commit_graph_generation(commit) < min_generation)
                        break;
 
                flags = commit->object.flags & (PARENT1 | PARENT2 | STALE);
@@ -176,7 +176,7 @@ static int remove_redundant(struct repository *r, struct commit **array, int cnt
                repo_parse_commit(r, array[i]);
        for (i = 0; i < cnt; i++) {
                struct commit_list *common;
-               uint32_t min_generation = array[i]->generation;
+               uint32_t min_generation = commit_graph_generation(array[i]);
 
                if (redundant[i])
                        continue;
@@ -186,8 +186,8 @@ static int remove_redundant(struct repository *r, struct commit **array, int cnt
                        filled_index[filled] = j;
                        work[filled++] = array[j];
 
-                       if (array[j]->generation < min_generation)
-                               min_generation = array[j]->generation;
+                       if (commit_graph_generation(array[j]) < min_generation)
+                               min_generation = commit_graph_generation(array[j]);
                }
                common = paint_down_to_common(r, array[i], filled,
                                              work, min_generation);
@@ -323,16 +323,16 @@ int repo_in_merge_bases_many(struct repository *r, struct commit *commit,
        for (i = 0; i < nr_reference; i++) {
                if (repo_parse_commit(r, reference[i]))
                        return ret;
-               if (reference[i]->generation < min_generation)
-                       min_generation = reference[i]->generation;
+               if (commit_graph_generation(reference[i]) < min_generation)
+                       min_generation = commit_graph_generation(reference[i]);
        }
 
-       if (commit->generation > min_generation)
+       if (commit_graph_generation(commit) > min_generation)
                return ret;
 
        bases = paint_down_to_common(r, commit,
                                     nr_reference, reference,
-                                    commit->generation);
+                                    commit_graph_generation(commit));
        if (commit->object.flags & PARENT2)
                ret = 1;
        clear_commit_marks(commit, all_flags);
@@ -467,7 +467,7 @@ static enum contains_result contains_test(struct commit *candidate,
        /* Otherwise, we don't know; prepare to recurse */
        parse_commit_or_die(candidate);
 
-       if (candidate->generation < cutoff)
+       if (commit_graph_generation(candidate) < cutoff)
                return CONTAINS_NO;
 
        return CONTAINS_UNKNOWN;
@@ -492,8 +492,8 @@ static enum contains_result contains_tag_algo(struct commit *candidate,
        for (p = want; p; p = p->next) {
                struct commit *c = p->item;
                load_commit_graph_info(the_repository, c);
-               if (c->generation < cutoff)
-                       cutoff = c->generation;
+               if (commit_graph_generation(c) < cutoff)
+                       cutoff = commit_graph_generation(c);
        }
 
        result = contains_test(candidate, want, cache, cutoff);
@@ -544,9 +544,9 @@ static int compare_commits_by_gen(const void *_a, const void *_b)
        const struct commit *a = *(const struct commit * const *)_a;
        const struct commit *b = *(const struct commit * const *)_b;
 
-       if (a->generation < b->generation)
+       if (commit_graph_generation(a) < commit_graph_generation(b))
                return -1;
-       if (a->generation > b->generation)
+       if (commit_graph_generation(a) > commit_graph_generation(b))
                return 1;
        return 0;
 }
@@ -585,7 +585,7 @@ int can_all_from_reach_with_flag(struct object_array *from,
 
                list[nr_commits] = (struct commit *)from_one;
                if (parse_commit(list[nr_commits]) ||
-                   list[nr_commits]->generation < min_generation) {
+                   commit_graph_generation(list[nr_commits]) < min_generation) {
                        result = 0;
                        goto cleanup;
                }
@@ -621,7 +621,7 @@ int can_all_from_reach_with_flag(struct object_array *from,
 
                                        if (parse_commit(parent->item) ||
                                            parent->item->date < min_commit_date ||
-                                           parent->item->generation < min_generation)
+                                           commit_graph_generation(parent->item) < min_generation)
                                                continue;
 
                                        commit_list_insert(parent->item, &stack);
@@ -665,8 +665,8 @@ int can_all_from_reach(struct commit_list *from, struct commit_list *to,
                        if (from_iter->item->date < min_commit_date)
                                min_commit_date = from_iter->item->date;
 
-                       if (from_iter->item->generation < min_generation)
-                               min_generation = from_iter->item->generation;
+                       if (commit_graph_generation(from_iter->item) < min_generation)
+                               min_generation = commit_graph_generation(from_iter->item);
                }
 
                from_iter = from_iter->next;
@@ -677,8 +677,8 @@ int can_all_from_reach(struct commit_list *from, struct commit_list *to,
                        if (to_iter->item->date < min_commit_date)
                                min_commit_date = to_iter->item->date;
 
-                       if (to_iter->item->generation < min_generation)
-                               min_generation = to_iter->item->generation;
+                       if (commit_graph_generation(to_iter->item) < min_generation)
+                               min_generation = commit_graph_generation(to_iter->item);
                }
 
                to_iter->item->object.flags |= PARENT2;
@@ -721,8 +721,8 @@ struct commit_list *get_reachable_subset(struct commit **from, int nr_from,
                struct commit *c = *item;
 
                parse_commit(c);
-               if (c->generation < min_generation)
-                       min_generation = c->generation;
+               if (commit_graph_generation(c) < min_generation)
+                       min_generation = commit_graph_generation(c);
 
                if (!(c->object.flags & PARENT1)) {
                        c->object.flags |= PARENT1;
@@ -755,7 +755,7 @@ struct commit_list *get_reachable_subset(struct commit **from, int nr_from,
 
                        parse_commit(p);
 
-                       if (p->generation < min_generation)
+                       if (commit_graph_generation(p) < min_generation)
                                continue;
 
                        if (p->object.flags & PARENT2)

diff --git a/commit.c b/commit.c
index b30875e66bfd6e0db92dfde7212367da23e2c0dd..ed0917a2c7612567d8018ca21a94f67e8ec287b8 100644 (file)
--- a/commit.c
+++ b/commit.c
@@ -339,7 +339,7 @@ struct tree *repo_get_commit_tree(struct repository *r,
        if (commit->maybe_tree || !commit->object.parsed)
                return commit->maybe_tree;
 
-       if (commit->graph_pos != COMMIT_NOT_FROM_GRAPH)
+       if (commit_graph_position(commit) != COMMIT_NOT_FROM_GRAPH)
                return get_commit_tree_in_graph(r, commit);
 
        return NULL;
@@ -731,9 +731,9 @@ int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, void
        const struct commit *a = a_, *b = b_;
 
        /* newer commits first */
-       if (a->generation < b->generation)
+       if (commit_graph_generation(a) < commit_graph_generation(b))
                return 1;
-       else if (a->generation > b->generation)
+       else if (commit_graph_generation(a) > commit_graph_generation(b))
                return -1;
 
        /* use date as a heuristic when generations are equal */

diff --git a/commit.h b/commit.h
index 1b2dea5d85ebe52c8e5f32f1e5e26ff33e0c566c..e90153890954a458fa83671dea14b07a76621747 100644 (file)
--- a/commit.h
+++ b/commit.h
@@ -36,8 +36,6 @@ struct commit {
         * or get_commit_tree_oid().
         */
        struct tree *maybe_tree;
-       uint32_t graph_pos;
-       uint32_t generation;
        unsigned int index;
 };
 

diff --git a/contrib/coccinelle/commit.cocci b/contrib/coccinelle/commit.cocci
index 778e4704f6a2baa8484a13fea3a0cf4d2b35f44b..af6dd4c20cae87d3364b59cedac80936f8ff3355 100644 (file)
--- a/contrib/coccinelle/commit.cocci
+++ b/contrib/coccinelle/commit.cocci
@@ -32,3 +32,21 @@ expression c;
 - c->maybe_tree
 + repo_get_commit_tree(specify_the_right_repo_here, c)
   ...>}
+
+@@
+struct commit *c;
+expression E;
+@@
+(
+- c->generation = E;
++ commit_graph_data_at(c)->generation = E;
+|
+- c->graph_pos = E;
++ commit_graph_data_at(c)->graph_pos = E;
+|
+- c->generation
++ commit_graph_generation(c)
+|
+- c->graph_pos
++ commit_graph_position(c)
+)

diff --git a/revision.c b/revision.c
index ebb4d2a0f2e62e54d4680fc0968796db0ff92750..8648d7c43ce3d030250c0f8aa8ff55b28b5fb67c 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -725,7 +725,7 @@ static int check_maybe_different_in_bloom_filter(struct rev_info *revs,
        if (!revs->repo->objects->commit_graph)
                return -1;
 
-       if (commit->generation == GENERATION_NUMBER_INFINITY)
+       if (commit_graph_generation(commit) == GENERATION_NUMBER_INFINITY)
                return -1;
 
        filter = get_bloom_filter(revs->repo, commit, 0);
@@ -3320,7 +3320,7 @@ static void explore_to_depth(struct rev_info *revs,
        struct topo_walk_info *info = revs->topo_walk_info;
        struct commit *c;
        while ((c = prio_queue_peek(&info->explore_queue)) &&
-              c->generation >= gen_cutoff)
+              commit_graph_generation(c) >= gen_cutoff)
                explore_walk_step(revs);
 }
 
@@ -3336,7 +3336,7 @@ static void indegree_walk_step(struct rev_info *revs)
        if (parse_commit_gently(c, 1) < 0)
                return;
 
-       explore_to_depth(revs, c->generation);
+       explore_to_depth(revs, commit_graph_generation(c));
 
        for (p = c->parents; p; p = p->next) {
                struct commit *parent = p->item;
@@ -3360,7 +3360,7 @@ static void compute_indegrees_to_depth(struct rev_info *revs,
        struct topo_walk_info *info = revs->topo_walk_info;
        struct commit *c;
        while ((c = prio_queue_peek(&info->indegree_queue)) &&
-              c->generation >= gen_cutoff)
+              commit_graph_generation(c) >= gen_cutoff)
                indegree_walk_step(revs);
 }
 
@@ -3420,8 +3420,8 @@ static void init_topo_walk(struct rev_info *revs)
                test_flag_and_insert(&info->explore_queue, c, TOPO_WALK_EXPLORED);
                test_flag_and_insert(&info->indegree_queue, c, TOPO_WALK_INDEGREE);
 
-               if (c->generation < info->min_generation)
-                       info->min_generation = c->generation;
+               if (commit_graph_generation(c) < info->min_generation)
+                       info->min_generation = commit_graph_generation(c);
 
                *(indegree_slab_at(&info->indegree, c)) = 1;
 
@@ -3479,8 +3479,8 @@ static void expand_topo_walk(struct rev_info *revs, struct commit *commit)
                if (parse_commit_gently(parent, 1) < 0)
                        continue;
 
-               if (parent->generation < info->min_generation) {
-                       info->min_generation = parent->generation;
+               if (commit_graph_generation(parent) < info->min_generation) {
+                       info->min_generation = commit_graph_generation(parent);
                        compute_indegrees_to_depth(revs, info->min_generation);
                }