Merge branch 'ak/commit-graph-to-slab'

A few fields in "struct commit" that do not have to always be
present have been moved to commit slabs.

* ak/commit-graph-to-slab:
  commit-graph: minimize commit_graph_data_slab access
  commit: move members graph_pos, generation to a slab
  commit-graph: introduce commit_graph_data_slab
  object: drop parsed_object_pool->commit_count
This commit is contained in:
Junio C Hamano 2020-07-06 22:09:13 -07:00
commit d80bea479d
20 changed files with 217 additions and 94 deletions

18
alloc.c
View File

@ -99,23 +99,27 @@ void *alloc_object_node(struct repository *r)
return obj; return obj;
} }
static unsigned int alloc_commit_index(struct repository *r) /*
* The returned count is to be used as an index into commit slabs,
* that are *NOT* maintained per repository, and that is why a single
* global counter is used.
*/
static unsigned int alloc_commit_index(void)
{ {
return r->parsed_objects->commit_count++; static unsigned int parsed_commits_count;
return parsed_commits_count++;
} }
void init_commit_node(struct repository *r, struct commit *c) void init_commit_node(struct commit *c)
{ {
c->object.type = OBJ_COMMIT; c->object.type = OBJ_COMMIT;
c->index = alloc_commit_index(r); c->index = alloc_commit_index();
c->graph_pos = COMMIT_NOT_FROM_GRAPH;
c->generation = GENERATION_NUMBER_INFINITY;
} }
void *alloc_commit_node(struct repository *r) void *alloc_commit_node(struct repository *r)
{ {
struct commit *c = alloc_node(r->parsed_objects->commit_state, sizeof(struct commit)); struct commit *c = alloc_node(r->parsed_objects->commit_state, sizeof(struct commit));
init_commit_node(r, c); init_commit_node(c);
return c; return c;
} }

View File

@ -9,7 +9,7 @@ struct repository;
void *alloc_blob_node(struct repository *r); void *alloc_blob_node(struct repository *r);
void *alloc_tree_node(struct repository *r); void *alloc_tree_node(struct repository *r);
void init_commit_node(struct repository *r, struct commit *c); void init_commit_node(struct commit *c);
void *alloc_commit_node(struct repository *r); void *alloc_commit_node(struct repository *r);
void *alloc_tag_node(struct repository *r); void *alloc_tag_node(struct repository *r);
void *alloc_object_node(struct repository *r); void *alloc_object_node(struct repository *r);

View File

@ -1272,7 +1272,7 @@ static int maybe_changed_path(struct repository *r,
if (!bd) if (!bd)
return 1; return 1;
if (origin->commit->generation == GENERATION_NUMBER_INFINITY) if (commit_graph_generation(origin->commit) == GENERATION_NUMBER_INFINITY)
return 1; return 1;
filter = get_bloom_filter(r, origin->commit, 0); filter = get_bloom_filter(r, origin->commit, 0);

2
blob.c
View File

@ -10,7 +10,7 @@ struct blob *lookup_blob(struct repository *r, const struct object_id *oid)
struct object *obj = lookup_object(r, oid); struct object *obj = lookup_object(r, oid);
if (!obj) if (!obj)
return create_object(r, oid, alloc_blob_node(r)); return create_object(r, oid, alloc_blob_node(r));
return object_as_type(r, obj, OBJ_BLOB, 0); return object_as_type(obj, OBJ_BLOB, 0);
} }
int parse_blob_buffer(struct blob *item, void *buffer, unsigned long size) int parse_blob_buffer(struct blob *item, void *buffer, unsigned long size)

View File

@ -33,15 +33,16 @@ static int load_bloom_filter_from_graph(struct commit_graph *g,
struct commit *c) struct commit *c)
{ {
uint32_t lex_pos, start_index, end_index; uint32_t lex_pos, start_index, end_index;
uint32_t graph_pos = commit_graph_position(c);
while (c->graph_pos < g->num_commits_in_base) while (graph_pos < g->num_commits_in_base)
g = g->base_graph; g = g->base_graph;
/* The commit graph commit 'c' lives in doesn't carry bloom filters. */ /* The commit graph commit 'c' lives in doesn't carry bloom filters. */
if (!g->chunk_bloom_indexes) if (!g->chunk_bloom_indexes)
return 0; return 0;
lex_pos = c->graph_pos - g->num_commits_in_base; lex_pos = graph_pos - g->num_commits_in_base;
end_index = get_be32(g->chunk_bloom_indexes + 4 * lex_pos); end_index = get_be32(g->chunk_bloom_indexes + 4 * lex_pos);
@ -193,7 +194,7 @@ struct bloom_filter *get_bloom_filter(struct repository *r,
if (!filter->data) { if (!filter->data) {
load_commit_graph_info(r, c); 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) { r->objects->commit_graph->chunk_bloom_indexes) {
if (load_bloom_filter_from_graph(r->objects->commit_graph, filter, c)) if (load_bloom_filter_from_graph(r->objects->commit_graph, filter, c))
return filter; return filter;

View File

@ -154,7 +154,7 @@ static int read_one_commit(struct oidset *commits, struct progress *progress,
NULL, 0); NULL, 0);
if (!result) if (!result)
return error(_("invalid object: %s"), hash); return error(_("invalid object: %s"), hash);
else if (object_as_type(the_repository, result, OBJ_COMMIT, 1)) else if (object_as_type(result, OBJ_COMMIT, 1))
oidset_insert(commits, &result->oid); oidset_insert(commits, &result->oid);
display_progress(progress, oidset_size(commits)); display_progress(progress, oidset_size(commits));

View File

@ -241,7 +241,7 @@ static void mark_unreachable_referents(const struct object_id *oid)
enum object_type type = oid_object_info(the_repository, enum object_type type = oid_object_info(the_repository,
&obj->oid, NULL); &obj->oid, NULL);
if (type > 0) if (type > 0)
object_as_type(the_repository, obj, type, 0); object_as_type(obj, type, 0);
} }
options.walk = mark_used; options.walk = mark_used;

View File

@ -87,15 +87,69 @@ static int commit_pos_cmp(const void *va, const void *vb)
commit_pos_at(&commit_pos, b); commit_pos_at(&commit_pos, b);
} }
define_commit_slab(commit_graph_data_slab, struct commit_graph_data);
static struct commit_graph_data_slab commit_graph_data_slab =
COMMIT_SLAB_INIT(1, commit_graph_data_slab);
uint32_t commit_graph_position(const struct commit *c)
{
struct commit_graph_data *data =
commit_graph_data_slab_peek(&commit_graph_data_slab, c);
return data ? data->graph_pos : COMMIT_NOT_FROM_GRAPH;
}
uint32_t commit_graph_generation(const struct commit *c)
{
struct commit_graph_data *data =
commit_graph_data_slab_peek(&commit_graph_data_slab, c);
if (!data)
return GENERATION_NUMBER_INFINITY;
else if (data->graph_pos == COMMIT_NOT_FROM_GRAPH)
return GENERATION_NUMBER_INFINITY;
return data->generation;
}
static struct commit_graph_data *commit_graph_data_at(const struct commit *c)
{
unsigned int i, nth_slab;
struct commit_graph_data *data =
commit_graph_data_slab_peek(&commit_graph_data_slab, c);
if (data)
return data;
nth_slab = c->index / commit_graph_data_slab.slab_size;
data = commit_graph_data_slab_at(&commit_graph_data_slab, c);
/*
* commit-slab initializes elements with zero, overwrite this with
* COMMIT_NOT_FROM_GRAPH for graph_pos.
*
* We avoid initializing generation with checking if graph position
* is not COMMIT_NOT_FROM_GRAPH.
*/
for (i = 0; i < commit_graph_data_slab.slab_size; i++) {
commit_graph_data_slab.slab[nth_slab][i].graph_pos =
COMMIT_NOT_FROM_GRAPH;
}
return data;
}
static int commit_gen_cmp(const void *va, const void *vb) static int commit_gen_cmp(const void *va, const void *vb)
{ {
const struct commit *a = *(const struct commit **)va; const struct commit *a = *(const struct commit **)va;
const struct commit *b = *(const struct commit **)vb; const struct commit *b = *(const struct commit **)vb;
uint32_t generation_a = commit_graph_generation(a);
uint32_t generation_b = commit_graph_generation(b);
/* lower generation commits first */ /* lower generation commits first */
if (a->generation < b->generation) if (generation_a < generation_b)
return -1; return -1;
else if (a->generation > b->generation) else if (generation_a > generation_b)
return 1; return 1;
/* use date as a heuristic when generations are equal */ /* use date as a heuristic when generations are equal */
@ -670,13 +724,14 @@ static struct commit_list **insert_parent_or_die(struct repository *r,
c = lookup_commit(r, &oid); c = lookup_commit(r, &oid);
if (!c) if (!c)
die(_("could not find commit %s"), oid_to_hex(&oid)); 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; return &commit_list_insert(c, pptr)->next;
} }
static void fill_commit_graph_info(struct commit *item, struct commit_graph *g, uint32_t pos) static void fill_commit_graph_info(struct commit *item, struct commit_graph *g, uint32_t pos)
{ {
const unsigned char *commit_data; const unsigned char *commit_data;
struct commit_graph_data *graph_data;
uint32_t lex_index; uint32_t lex_index;
while (pos < g->num_commits_in_base) while (pos < g->num_commits_in_base)
@ -684,8 +739,10 @@ static void fill_commit_graph_info(struct commit *item, struct commit_graph *g,
lex_index = pos - g->num_commits_in_base; lex_index = pos - g->num_commits_in_base;
commit_data = g->chunk_commit_data + GRAPH_DATA_WIDTH * lex_index; 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; graph_data = commit_graph_data_at(item);
graph_data->graph_pos = pos;
graph_data->generation = get_be32(commit_data + g->hash_len + 8) >> 2;
} }
static inline void set_commit_tree(struct commit *c, struct tree *t) static inline void set_commit_tree(struct commit *c, struct tree *t)
@ -701,6 +758,7 @@ static int fill_commit_in_graph(struct repository *r,
uint32_t *parent_data_ptr; uint32_t *parent_data_ptr;
uint64_t date_low, date_high; uint64_t date_low, date_high;
struct commit_list **pptr; struct commit_list **pptr;
struct commit_graph_data *graph_data;
const unsigned char *commit_data; const unsigned char *commit_data;
uint32_t lex_index; uint32_t lex_index;
@ -714,7 +772,8 @@ static int fill_commit_in_graph(struct repository *r,
* Store the "full" position, but then use the * Store the "full" position, but then use the
* "local" position for the rest of the calculation. * "local" position for the rest of the calculation.
*/ */
item->graph_pos = pos; graph_data = commit_graph_data_at(item);
graph_data->graph_pos = pos;
lex_index = pos - g->num_commits_in_base; lex_index = pos - g->num_commits_in_base;
commit_data = g->chunk_commit_data + (g->hash_len + 16) * lex_index; commit_data = g->chunk_commit_data + (g->hash_len + 16) * lex_index;
@ -727,7 +786,7 @@ static int fill_commit_in_graph(struct repository *r,
date_low = get_be32(commit_data + g->hash_len + 12); date_low = get_be32(commit_data + g->hash_len + 12);
item->date = (timestamp_t)((date_high << 32) | date_low); item->date = (timestamp_t)((date_high << 32) | date_low);
item->generation = get_be32(commit_data + g->hash_len + 8) >> 2; graph_data->generation = get_be32(commit_data + g->hash_len + 8) >> 2;
pptr = &item->parents; pptr = &item->parents;
@ -759,8 +818,9 @@ 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) static int find_commit_in_graph(struct commit *item, struct commit_graph *g, uint32_t *pos)
{ {
if (item->graph_pos != COMMIT_NOT_FROM_GRAPH) { uint32_t graph_pos = commit_graph_position(item);
*pos = item->graph_pos; if (graph_pos != COMMIT_NOT_FROM_GRAPH) {
*pos = graph_pos;
return 1; return 1;
} else { } else {
struct commit_graph *cur_g = g; struct commit_graph *cur_g = g;
@ -815,12 +875,13 @@ static struct tree *load_tree_for_commit(struct repository *r,
{ {
struct object_id oid; struct object_id oid;
const unsigned char *commit_data; const unsigned char *commit_data;
uint32_t graph_pos = commit_graph_position(c);
while (c->graph_pos < g->num_commits_in_base) while (graph_pos < g->num_commits_in_base)
g = g->base_graph; g = g->base_graph;
commit_data = g->chunk_commit_data + commit_data = g->chunk_commit_data +
GRAPH_DATA_WIDTH * (c->graph_pos - g->num_commits_in_base); GRAPH_DATA_WIDTH * (graph_pos - g->num_commits_in_base);
hashcpy(oid.hash, commit_data); hashcpy(oid.hash, commit_data);
set_commit_tree(c, lookup_tree(r, &oid)); set_commit_tree(c, lookup_tree(r, &oid));
@ -834,7 +895,7 @@ static struct tree *get_commit_tree_in_graph_one(struct repository *r,
{ {
if (c->maybe_tree) if (c->maybe_tree)
return 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"); BUG("get_commit_tree_in_graph_one called from non-commit-graph commit");
return load_tree_for_commit(r, g, (struct commit *)c); return load_tree_for_commit(r, g, (struct commit *)c);
@ -1020,7 +1081,7 @@ static void write_graph_chunk_data(struct hashfile *f, int hash_len,
else else
packedDate[0] = 0; packedDate[0] = 0;
packedDate[0] |= htonl((*list)->generation << 2); packedDate[0] |= htonl(commit_graph_data_at(*list)->generation << 2);
packedDate[1] = htonl((*list)->date); packedDate[1] = htonl((*list)->date);
hashwrite(f, packedDate, 8); hashwrite(f, packedDate, 8);
@ -1219,7 +1280,7 @@ static void close_reachable(struct write_commit_graph_context *ctx)
continue; continue;
if (ctx->split) { if (ctx->split) {
if ((!parse_commit(commit) && if ((!parse_commit(commit) &&
commit->graph_pos == COMMIT_NOT_FROM_GRAPH) || commit_graph_position(commit) == COMMIT_NOT_FROM_GRAPH) ||
flags == COMMIT_GRAPH_SPLIT_REPLACE) flags == COMMIT_GRAPH_SPLIT_REPLACE)
add_missing_parents(ctx, commit); add_missing_parents(ctx, commit);
} else if (!parse_commit_no_graph(commit)) } else if (!parse_commit_no_graph(commit))
@ -1251,9 +1312,11 @@ static void compute_generation_numbers(struct write_commit_graph_context *ctx)
_("Computing commit graph generation numbers"), _("Computing commit graph generation numbers"),
ctx->commits.nr); ctx->commits.nr);
for (i = 0; i < ctx->commits.nr; i++) { for (i = 0; i < ctx->commits.nr; i++) {
uint32_t generation = commit_graph_data_at(ctx->commits.list[i])->generation;
display_progress(ctx->progress, i + 1); display_progress(ctx->progress, i + 1);
if (ctx->commits.list[i]->generation != GENERATION_NUMBER_INFINITY && if (generation != GENERATION_NUMBER_INFINITY &&
ctx->commits.list[i]->generation != GENERATION_NUMBER_ZERO) generation != GENERATION_NUMBER_ZERO)
continue; continue;
commit_list_insert(ctx->commits.list[i], &list); commit_list_insert(ctx->commits.list[i], &list);
@ -1264,22 +1327,26 @@ static void compute_generation_numbers(struct write_commit_graph_context *ctx)
uint32_t max_generation = 0; uint32_t max_generation = 0;
for (parent = current->parents; parent; parent = parent->next) { for (parent = current->parents; parent; parent = parent->next) {
if (parent->item->generation == GENERATION_NUMBER_INFINITY || generation = commit_graph_data_at(parent->item)->generation;
parent->item->generation == GENERATION_NUMBER_ZERO) {
if (generation == GENERATION_NUMBER_INFINITY ||
generation == GENERATION_NUMBER_ZERO) {
all_parents_computed = 0; all_parents_computed = 0;
commit_list_insert(parent->item, &list); commit_list_insert(parent->item, &list);
break; break;
} else if (parent->item->generation > max_generation) { } else if (generation > max_generation) {
max_generation = parent->item->generation; max_generation = generation;
} }
} }
if (all_parents_computed) { if (all_parents_computed) {
current->generation = max_generation + 1; struct commit_graph_data *data = commit_graph_data_at(current);
data->generation = max_generation + 1;
pop_commit(&list); pop_commit(&list);
if (current->generation > GENERATION_NUMBER_MAX) if (data->generation > GENERATION_NUMBER_MAX)
current->generation = GENERATION_NUMBER_MAX; data->generation = GENERATION_NUMBER_MAX;
} }
} }
} }
@ -1458,7 +1525,7 @@ static uint32_t count_distinct_commits(struct write_commit_graph_context *ctx)
if (ctx->split) { if (ctx->split) {
struct commit *c = lookup_commit(ctx->r, &ctx->oids.list[i]); 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; continue;
} }
@ -1492,7 +1559,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]); ctx->commits.list[ctx->commits.nr] = lookup_commit(ctx->r, &ctx->oids.list[i]);
if (ctx->split && flags != COMMIT_GRAPH_SPLIT_REPLACE && 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; continue;
if (ctx->split && flags == COMMIT_GRAPH_SPLIT_REPLACE) if (ctx->split && flags == COMMIT_GRAPH_SPLIT_REPLACE)
@ -2241,6 +2308,7 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags)
struct commit *graph_commit, *odb_commit; struct commit *graph_commit, *odb_commit;
struct commit_list *graph_parents, *odb_parents; struct commit_list *graph_parents, *odb_parents;
uint32_t max_generation = 0; uint32_t max_generation = 0;
uint32_t generation;
display_progress(progress, i + 1); display_progress(progress, i + 1);
hashcpy(cur_oid.hash, g->chunk_oid_lookup + g->hash_len * i); hashcpy(cur_oid.hash, g->chunk_oid_lookup + g->hash_len * i);
@ -2279,8 +2347,9 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags)
oid_to_hex(&graph_parents->item->object.oid), oid_to_hex(&graph_parents->item->object.oid),
oid_to_hex(&odb_parents->item->object.oid)); oid_to_hex(&odb_parents->item->object.oid));
if (graph_parents->item->generation > max_generation) generation = commit_graph_generation(graph_parents->item);
max_generation = graph_parents->item->generation; if (generation > max_generation)
max_generation = generation;
graph_parents = graph_parents->next; graph_parents = graph_parents->next;
odb_parents = odb_parents->next; odb_parents = odb_parents->next;
@ -2290,7 +2359,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"), graph_report(_("commit-graph parent list for commit %s terminates early"),
oid_to_hex(&cur_oid)); oid_to_hex(&cur_oid));
if (!graph_commit->generation) { if (!commit_graph_generation(graph_commit)) {
if (generation_zero == GENERATION_NUMBER_EXISTS) if (generation_zero == GENERATION_NUMBER_EXISTS)
graph_report(_("commit-graph has generation number zero for commit %s, but non-zero elsewhere"), graph_report(_("commit-graph has generation number zero for commit %s, but non-zero elsewhere"),
oid_to_hex(&cur_oid)); oid_to_hex(&cur_oid));
@ -2310,10 +2379,11 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags)
if (max_generation == GENERATION_NUMBER_MAX) if (max_generation == GENERATION_NUMBER_MAX)
max_generation--; max_generation--;
if (graph_commit->generation != max_generation + 1) generation = commit_graph_generation(graph_commit);
if (generation != max_generation + 1)
graph_report(_("commit-graph generation for commit %s is %u != %u"), graph_report(_("commit-graph generation for commit %s is %u != %u"),
oid_to_hex(&cur_oid), oid_to_hex(&cur_oid),
graph_commit->generation, generation,
max_generation + 1); max_generation + 1);
if (graph_commit->date != odb_commit->date) if (graph_commit->date != odb_commit->date)

View File

@ -135,4 +135,14 @@ void free_commit_graph(struct commit_graph *);
*/ */
void disable_commit_graph(struct repository *r); void disable_commit_graph(struct repository *r);
struct commit_graph_data {
uint32_t graph_pos;
uint32_t generation;
};
/*
* Commits should be parsed before accessing generation, graph positions.
*/
uint32_t commit_graph_generation(const struct commit *);
uint32_t commit_graph_position(const struct commit *);
#endif #endif

View File

@ -58,14 +58,15 @@ static struct commit_list *paint_down_to_common(struct repository *r,
struct commit *commit = prio_queue_get(&queue); struct commit *commit = prio_queue_get(&queue);
struct commit_list *parents; struct commit_list *parents;
int flags; int flags;
uint32_t generation = commit_graph_generation(commit);
if (min_generation && commit->generation > last_gen) if (min_generation && generation > last_gen)
BUG("bad generation skip %8x > %8x at %s", BUG("bad generation skip %8x > %8x at %s",
commit->generation, last_gen, generation, last_gen,
oid_to_hex(&commit->object.oid)); oid_to_hex(&commit->object.oid));
last_gen = commit->generation; last_gen = generation;
if (commit->generation < min_generation) if (generation < min_generation)
break; break;
flags = commit->object.flags & (PARENT1 | PARENT2 | STALE); flags = commit->object.flags & (PARENT1 | PARENT2 | STALE);
@ -176,18 +177,20 @@ static int remove_redundant(struct repository *r, struct commit **array, int cnt
repo_parse_commit(r, array[i]); repo_parse_commit(r, array[i]);
for (i = 0; i < cnt; i++) { for (i = 0; i < cnt; i++) {
struct commit_list *common; struct commit_list *common;
uint32_t min_generation = array[i]->generation; uint32_t min_generation = commit_graph_generation(array[i]);
if (redundant[i]) if (redundant[i])
continue; continue;
for (j = filled = 0; j < cnt; j++) { for (j = filled = 0; j < cnt; j++) {
uint32_t curr_generation;
if (i == j || redundant[j]) if (i == j || redundant[j])
continue; continue;
filled_index[filled] = j; filled_index[filled] = j;
work[filled++] = array[j]; work[filled++] = array[j];
if (array[j]->generation < min_generation) curr_generation = commit_graph_generation(array[j]);
min_generation = array[j]->generation; if (curr_generation < min_generation)
min_generation = curr_generation;
} }
common = paint_down_to_common(r, array[i], filled, common = paint_down_to_common(r, array[i], filled,
work, min_generation); work, min_generation);
@ -323,23 +326,26 @@ int repo_in_merge_bases_many(struct repository *r, struct commit *commit,
{ {
struct commit_list *bases; struct commit_list *bases;
int ret = 0, i; int ret = 0, i;
uint32_t min_generation = GENERATION_NUMBER_INFINITY; uint32_t generation, min_generation = GENERATION_NUMBER_INFINITY;
if (repo_parse_commit(r, commit)) if (repo_parse_commit(r, commit))
return ret; return ret;
for (i = 0; i < nr_reference; i++) { for (i = 0; i < nr_reference; i++) {
if (repo_parse_commit(r, reference[i])) if (repo_parse_commit(r, reference[i]))
return ret; return ret;
if (reference[i]->generation < min_generation)
min_generation = reference[i]->generation; generation = commit_graph_generation(reference[i]);
if (generation < min_generation)
min_generation = generation;
} }
if (commit->generation > min_generation) generation = commit_graph_generation(commit);
if (generation > min_generation)
return ret; return ret;
bases = paint_down_to_common(r, commit, bases = paint_down_to_common(r, commit,
nr_reference, reference, nr_reference, reference,
commit->generation); generation);
if (commit->object.flags & PARENT2) if (commit->object.flags & PARENT2)
ret = 1; ret = 1;
clear_commit_marks(commit, all_flags); clear_commit_marks(commit, all_flags);
@ -485,7 +491,7 @@ static enum contains_result contains_test(struct commit *candidate,
/* Otherwise, we don't know; prepare to recurse */ /* Otherwise, we don't know; prepare to recurse */
parse_commit_or_die(candidate); parse_commit_or_die(candidate);
if (candidate->generation < cutoff) if (commit_graph_generation(candidate) < cutoff)
return CONTAINS_NO; return CONTAINS_NO;
return CONTAINS_UNKNOWN; return CONTAINS_UNKNOWN;
@ -508,10 +514,12 @@ static enum contains_result contains_tag_algo(struct commit *candidate,
const struct commit_list *p; const struct commit_list *p;
for (p = want; p; p = p->next) { for (p = want; p; p = p->next) {
uint32_t generation;
struct commit *c = p->item; struct commit *c = p->item;
load_commit_graph_info(the_repository, c); load_commit_graph_info(the_repository, c);
if (c->generation < cutoff) generation = commit_graph_generation(c);
cutoff = c->generation; if (generation < cutoff)
cutoff = generation;
} }
result = contains_test(candidate, want, cache, cutoff); result = contains_test(candidate, want, cache, cutoff);
@ -562,9 +570,12 @@ static int compare_commits_by_gen(const void *_a, const void *_b)
const struct commit *a = *(const struct commit * const *)_a; const struct commit *a = *(const struct commit * const *)_a;
const struct commit *b = *(const struct commit * const *)_b; const struct commit *b = *(const struct commit * const *)_b;
if (a->generation < b->generation) uint32_t generation_a = commit_graph_generation(a);
uint32_t generation_b = commit_graph_generation(b);
if (generation_a < generation_b)
return -1; return -1;
if (a->generation > b->generation) if (generation_a > generation_b)
return 1; return 1;
return 0; return 0;
} }
@ -603,7 +614,7 @@ int can_all_from_reach_with_flag(struct object_array *from,
list[nr_commits] = (struct commit *)from_one; list[nr_commits] = (struct commit *)from_one;
if (parse_commit(list[nr_commits]) || if (parse_commit(list[nr_commits]) ||
list[nr_commits]->generation < min_generation) { commit_graph_generation(list[nr_commits]) < min_generation) {
result = 0; result = 0;
goto cleanup; goto cleanup;
} }
@ -639,7 +650,7 @@ int can_all_from_reach_with_flag(struct object_array *from,
if (parse_commit(parent->item) || if (parse_commit(parent->item) ||
parent->item->date < min_commit_date || parent->item->date < min_commit_date ||
parent->item->generation < min_generation) commit_graph_generation(parent->item) < min_generation)
continue; continue;
commit_list_insert(parent->item, &stack); commit_list_insert(parent->item, &stack);
@ -680,11 +691,13 @@ int can_all_from_reach(struct commit_list *from, struct commit_list *to,
add_object_array(&from_iter->item->object, NULL, &from_objs); add_object_array(&from_iter->item->object, NULL, &from_objs);
if (!parse_commit(from_iter->item)) { if (!parse_commit(from_iter->item)) {
uint32_t generation;
if (from_iter->item->date < min_commit_date) if (from_iter->item->date < min_commit_date)
min_commit_date = from_iter->item->date; min_commit_date = from_iter->item->date;
if (from_iter->item->generation < min_generation) generation = commit_graph_generation(from_iter->item);
min_generation = from_iter->item->generation; if (generation < min_generation)
min_generation = generation;
} }
from_iter = from_iter->next; from_iter = from_iter->next;
@ -692,11 +705,13 @@ int can_all_from_reach(struct commit_list *from, struct commit_list *to,
while (to_iter) { while (to_iter) {
if (!parse_commit(to_iter->item)) { if (!parse_commit(to_iter->item)) {
uint32_t generation;
if (to_iter->item->date < min_commit_date) if (to_iter->item->date < min_commit_date)
min_commit_date = to_iter->item->date; min_commit_date = to_iter->item->date;
if (to_iter->item->generation < min_generation) generation = commit_graph_generation(to_iter->item);
min_generation = to_iter->item->generation; if (generation < min_generation)
min_generation = generation;
} }
to_iter->item->object.flags |= PARENT2; to_iter->item->object.flags |= PARENT2;
@ -736,11 +751,13 @@ struct commit_list *get_reachable_subset(struct commit **from, int nr_from,
struct prio_queue queue = { compare_commits_by_gen_then_commit_date }; struct prio_queue queue = { compare_commits_by_gen_then_commit_date };
for (item = to; item < to_last; item++) { for (item = to; item < to_last; item++) {
uint32_t generation;
struct commit *c = *item; struct commit *c = *item;
parse_commit(c); parse_commit(c);
if (c->generation < min_generation) generation = commit_graph_generation(c);
min_generation = c->generation; if (generation < min_generation)
min_generation = generation;
if (!(c->object.flags & PARENT1)) { if (!(c->object.flags & PARENT1)) {
c->object.flags |= PARENT1; c->object.flags |= PARENT1;
@ -773,7 +790,7 @@ struct commit_list *get_reachable_subset(struct commit **from, int nr_from,
parse_commit(p); parse_commit(p);
if (p->generation < min_generation) if (commit_graph_generation(p) < min_generation)
continue; continue;
if (p->object.flags & PARENT2) if (p->object.flags & PARENT2)

View File

@ -37,7 +37,7 @@ struct commit *lookup_commit_reference_gently(struct repository *r,
if (!obj) if (!obj)
return NULL; return NULL;
return object_as_type(r, obj, OBJ_COMMIT, quiet); return object_as_type(obj, OBJ_COMMIT, quiet);
} }
struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid) struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid)
@ -62,7 +62,7 @@ struct commit *lookup_commit(struct repository *r, const struct object_id *oid)
struct object *obj = lookup_object(r, oid); struct object *obj = lookup_object(r, oid);
if (!obj) if (!obj)
return create_object(r, oid, alloc_commit_node(r)); return create_object(r, oid, alloc_commit_node(r));
return object_as_type(r, obj, OBJ_COMMIT, 0); return object_as_type(obj, OBJ_COMMIT, 0);
} }
struct commit *lookup_commit_reference_by_name(const char *name) struct commit *lookup_commit_reference_by_name(const char *name)
@ -339,7 +339,7 @@ struct tree *repo_get_commit_tree(struct repository *r,
if (commit->maybe_tree || !commit->object.parsed) if (commit->maybe_tree || !commit->object.parsed)
return commit->maybe_tree; 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 get_commit_tree_in_graph(r, commit);
return NULL; return NULL;
@ -729,11 +729,13 @@ int compare_commits_by_author_date(const void *a_, const void *b_,
int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, void *unused) int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, void *unused)
{ {
const struct commit *a = a_, *b = b_; const struct commit *a = a_, *b = b_;
const uint32_t generation_a = commit_graph_generation(a),
generation_b = commit_graph_generation(b);
/* newer commits first */ /* newer commits first */
if (a->generation < b->generation) if (generation_a < generation_b)
return 1; return 1;
else if (a->generation > b->generation) else if (generation_a > generation_b)
return -1; return -1;
/* use date as a heuristic when generations are equal */ /* use date as a heuristic when generations are equal */

View File

@ -36,8 +36,6 @@ struct commit {
* or get_commit_tree_oid(). * or get_commit_tree_oid().
*/ */
struct tree *maybe_tree; struct tree *maybe_tree;
uint32_t graph_pos;
uint32_t generation;
unsigned int index; unsigned int index;
}; };

View File

@ -32,3 +32,21 @@ expression c;
- c->maybe_tree - c->maybe_tree
+ repo_get_commit_tree(specify_the_right_repo_here, c) + 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)
)

View File

@ -157,13 +157,13 @@ void *create_object(struct repository *r, const struct object_id *oid, void *o)
return obj; return obj;
} }
void *object_as_type(struct repository *r, struct object *obj, enum object_type type, int quiet) void *object_as_type(struct object *obj, enum object_type type, int quiet)
{ {
if (obj->type == type) if (obj->type == type)
return obj; return obj;
else if (obj->type == OBJ_NONE) { else if (obj->type == OBJ_NONE) {
if (type == OBJ_COMMIT) if (type == OBJ_COMMIT)
init_commit_node(r, (struct commit *) obj); init_commit_node((struct commit *) obj);
else else
obj->type = type; obj->type = type;
return obj; return obj;

View File

@ -15,7 +15,6 @@ struct parsed_object_pool {
struct alloc_state *commit_state; struct alloc_state *commit_state;
struct alloc_state *tag_state; struct alloc_state *tag_state;
struct alloc_state *object_state; struct alloc_state *object_state;
unsigned commit_count;
/* parent substitutions from .git/info/grafts and .git/shallow */ /* parent substitutions from .git/info/grafts and .git/shallow */
struct commit_graft **grafts; struct commit_graft **grafts;
@ -121,7 +120,7 @@ struct object *lookup_object(struct repository *r, const struct object_id *oid);
void *create_object(struct repository *r, const struct object_id *oid, void *obj); void *create_object(struct repository *r, const struct object_id *oid, void *obj);
void *object_as_type(struct repository *r, struct object *obj, enum object_type type, int quiet); void *object_as_type(struct object *obj, enum object_type type, int quiet);
/* /*
* Returns the object, having parsed it to find out what it is. * Returns the object, having parsed it to find out what it is.

2
refs.c
View File

@ -341,7 +341,7 @@ enum peel_status peel_object(const struct object_id *name, struct object_id *oid
if (o->type == OBJ_NONE) { if (o->type == OBJ_NONE) {
int type = oid_object_info(the_repository, name, NULL); int type = oid_object_info(the_repository, name, NULL);
if (type < 0 || !object_as_type(the_repository, o, type, 0)) if (type < 0 || !object_as_type(o, type, 0))
return PEEL_INVALID; return PEEL_INVALID;
} }

View File

@ -725,7 +725,7 @@ static int check_maybe_different_in_bloom_filter(struct rev_info *revs,
if (!revs->repo->objects->commit_graph) if (!revs->repo->objects->commit_graph)
return -1; return -1;
if (commit->generation == GENERATION_NUMBER_INFINITY) if (commit_graph_generation(commit) == GENERATION_NUMBER_INFINITY)
return -1; return -1;
filter = get_bloom_filter(revs->repo, commit, 0); 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 topo_walk_info *info = revs->topo_walk_info;
struct commit *c; struct commit *c;
while ((c = prio_queue_peek(&info->explore_queue)) && while ((c = prio_queue_peek(&info->explore_queue)) &&
c->generation >= gen_cutoff) commit_graph_generation(c) >= gen_cutoff)
explore_walk_step(revs); explore_walk_step(revs);
} }
@ -3336,7 +3336,7 @@ static void indegree_walk_step(struct rev_info *revs)
if (parse_commit_gently(c, 1) < 0) if (parse_commit_gently(c, 1) < 0)
return; return;
explore_to_depth(revs, c->generation); explore_to_depth(revs, commit_graph_generation(c));
for (p = c->parents; p; p = p->next) { for (p = c->parents; p; p = p->next) {
struct commit *parent = p->item; 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 topo_walk_info *info = revs->topo_walk_info;
struct commit *c; struct commit *c;
while ((c = prio_queue_peek(&info->indegree_queue)) && while ((c = prio_queue_peek(&info->indegree_queue)) &&
c->generation >= gen_cutoff) commit_graph_generation(c) >= gen_cutoff)
indegree_walk_step(revs); indegree_walk_step(revs);
} }
@ -3413,6 +3413,7 @@ static void init_topo_walk(struct rev_info *revs)
info->min_generation = GENERATION_NUMBER_INFINITY; info->min_generation = GENERATION_NUMBER_INFINITY;
for (list = revs->commits; list; list = list->next) { for (list = revs->commits; list; list = list->next) {
struct commit *c = list->item; struct commit *c = list->item;
uint32_t generation;
if (parse_commit_gently(c, 1)) if (parse_commit_gently(c, 1))
continue; continue;
@ -3420,8 +3421,9 @@ 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->explore_queue, c, TOPO_WALK_EXPLORED);
test_flag_and_insert(&info->indegree_queue, c, TOPO_WALK_INDEGREE); test_flag_and_insert(&info->indegree_queue, c, TOPO_WALK_INDEGREE);
if (c->generation < info->min_generation) generation = commit_graph_generation(c);
info->min_generation = c->generation; if (generation < info->min_generation)
info->min_generation = generation;
*(indegree_slab_at(&info->indegree, c)) = 1; *(indegree_slab_at(&info->indegree, c)) = 1;
@ -3472,6 +3474,7 @@ static void expand_topo_walk(struct rev_info *revs, struct commit *commit)
for (p = commit->parents; p; p = p->next) { for (p = commit->parents; p; p = p->next) {
struct commit *parent = p->item; struct commit *parent = p->item;
int *pi; int *pi;
uint32_t generation;
if (parent->object.flags & UNINTERESTING) if (parent->object.flags & UNINTERESTING)
continue; continue;
@ -3479,8 +3482,9 @@ static void expand_topo_walk(struct rev_info *revs, struct commit *commit)
if (parse_commit_gently(parent, 1) < 0) if (parse_commit_gently(parent, 1) < 0)
continue; continue;
if (parent->generation < info->min_generation) { generation = commit_graph_generation(parent);
info->min_generation = parent->generation; if (generation < info->min_generation) {
info->min_generation = generation;
compute_indegrees_to_depth(revs, info->min_generation); compute_indegrees_to_depth(revs, info->min_generation);
} }

View File

@ -67,7 +67,7 @@ int cmd__reach(int ac, const char **av)
die("failed to load commit for input %s resulting in oid %s\n", die("failed to load commit for input %s resulting in oid %s\n",
buf.buf, oid_to_hex(&oid)); buf.buf, oid_to_hex(&oid));
c = object_as_type(r, peeled, OBJ_COMMIT, 0); c = object_as_type(peeled, OBJ_COMMIT, 0);
if (!c) if (!c)
die("failed to load commit for input %s resulting in oid %s\n", die("failed to load commit for input %s resulting in oid %s\n",

2
tag.c
View File

@ -103,7 +103,7 @@ struct tag *lookup_tag(struct repository *r, const struct object_id *oid)
struct object *obj = lookup_object(r, oid); struct object *obj = lookup_object(r, oid);
if (!obj) if (!obj)
return create_object(r, oid, alloc_tag_node(r)); return create_object(r, oid, alloc_tag_node(r));
return object_as_type(r, obj, OBJ_TAG, 0); return object_as_type(obj, OBJ_TAG, 0);
} }
static timestamp_t parse_tag_date(const char *buf, const char *tail) static timestamp_t parse_tag_date(const char *buf, const char *tail)

2
tree.c
View File

@ -200,7 +200,7 @@ struct tree *lookup_tree(struct repository *r, const struct object_id *oid)
struct object *obj = lookup_object(r, oid); struct object *obj = lookup_object(r, oid);
if (!obj) if (!obj)
return create_object(r, oid, alloc_tree_node(r)); return create_object(r, oid, alloc_tree_node(r));
return object_as_type(r, obj, OBJ_TREE, 0); return object_as_type(obj, OBJ_TREE, 0);
} }
int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size) int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)