mirror of
https://github.com/git/git.git
synced 2024-10-31 06:17:56 +01:00
4468d4435c
When the commit graph and generation numbers were introduced in commits177722b344(commit: integrate commit graph with commit parsing, 2018-04-10) and83073cc994(commit: add generation number to struct commit, 2018-04-25), they tried to make sure that the corresponding 'graph_pos' and 'generation' fields of 'struct commit' are initialized conservatively, as if the commit were not included in the commit-graph file. Alas, initializing those fields only in alloc_commit_node() missed the case when an object that happens to be a commit is first looked up via lookup_unknown_object(), and is then later converted to a 'struct commit' via the object_as_type() helper function (either calling it directly, or as part of a subsequent lookup_commit() call). Consequently, both of those fields incorrectly remain set to zero, which means e.g. that the commit is present in and is the first entry of the commit-graph file. This will result in wrong timestamp, parent and root tree hashes, if such a 'struct commit' instance is later filled from the commit-graph. Extract the initialization of 'struct commit's fields from alloc_commit_node() into a helper function, and call it from object_as_type() as well, to make sure that it properly initializes the two commit-graph-related fields, too. With this helper function it is hopefully less likely that any new fields added to 'struct commit' in the future would remain uninitialized. With this change alloc_commit_index() won't have any remaining callers outside of 'alloc.c', so mark it as static. Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
139 lines
3.2 KiB
C
139 lines
3.2 KiB
C
/*
|
|
* alloc.c - specialized allocator for internal objects
|
|
*
|
|
* Copyright (C) 2006 Linus Torvalds
|
|
*
|
|
* The standard malloc/free wastes too much space for objects, partly because
|
|
* it maintains all the allocation infrastructure, but even more because it ends
|
|
* up with maximal alignment because it doesn't know what the object alignment
|
|
* for the new allocation is.
|
|
*/
|
|
#include "cache.h"
|
|
#include "object.h"
|
|
#include "blob.h"
|
|
#include "tree.h"
|
|
#include "commit.h"
|
|
#include "tag.h"
|
|
#include "alloc.h"
|
|
|
|
#define BLOCKING 1024
|
|
|
|
union any_object {
|
|
struct object object;
|
|
struct blob blob;
|
|
struct tree tree;
|
|
struct commit commit;
|
|
struct tag tag;
|
|
};
|
|
|
|
struct alloc_state {
|
|
int count; /* total number of nodes allocated */
|
|
int nr; /* number of nodes left in current allocation */
|
|
void *p; /* first free node in current allocation */
|
|
|
|
/* bookkeeping of allocations */
|
|
void **slabs;
|
|
int slab_nr, slab_alloc;
|
|
};
|
|
|
|
struct alloc_state *allocate_alloc_state(void)
|
|
{
|
|
return xcalloc(1, sizeof(struct alloc_state));
|
|
}
|
|
|
|
void clear_alloc_state(struct alloc_state *s)
|
|
{
|
|
while (s->slab_nr > 0) {
|
|
s->slab_nr--;
|
|
free(s->slabs[s->slab_nr]);
|
|
}
|
|
|
|
FREE_AND_NULL(s->slabs);
|
|
}
|
|
|
|
static inline void *alloc_node(struct alloc_state *s, size_t node_size)
|
|
{
|
|
void *ret;
|
|
|
|
if (!s->nr) {
|
|
s->nr = BLOCKING;
|
|
s->p = xmalloc(BLOCKING * node_size);
|
|
|
|
ALLOC_GROW(s->slabs, s->slab_nr + 1, s->slab_alloc);
|
|
s->slabs[s->slab_nr++] = s->p;
|
|
}
|
|
s->nr--;
|
|
s->count++;
|
|
ret = s->p;
|
|
s->p = (char *)s->p + node_size;
|
|
memset(ret, 0, node_size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void *alloc_blob_node(struct repository *r)
|
|
{
|
|
struct blob *b = alloc_node(r->parsed_objects->blob_state, sizeof(struct blob));
|
|
b->object.type = OBJ_BLOB;
|
|
return b;
|
|
}
|
|
|
|
void *alloc_tree_node(struct repository *r)
|
|
{
|
|
struct tree *t = alloc_node(r->parsed_objects->tree_state, sizeof(struct tree));
|
|
t->object.type = OBJ_TREE;
|
|
return t;
|
|
}
|
|
|
|
void *alloc_tag_node(struct repository *r)
|
|
{
|
|
struct tag *t = alloc_node(r->parsed_objects->tag_state, sizeof(struct tag));
|
|
t->object.type = OBJ_TAG;
|
|
return t;
|
|
}
|
|
|
|
void *alloc_object_node(struct repository *r)
|
|
{
|
|
struct object *obj = alloc_node(r->parsed_objects->object_state, sizeof(union any_object));
|
|
obj->type = OBJ_NONE;
|
|
return obj;
|
|
}
|
|
|
|
static unsigned int alloc_commit_index(struct repository *r)
|
|
{
|
|
return r->parsed_objects->commit_count++;
|
|
}
|
|
|
|
void init_commit_node(struct repository *r, struct commit *c)
|
|
{
|
|
c->object.type = OBJ_COMMIT;
|
|
c->index = alloc_commit_index(r);
|
|
c->graph_pos = COMMIT_NOT_FROM_GRAPH;
|
|
c->generation = GENERATION_NUMBER_INFINITY;
|
|
}
|
|
|
|
void *alloc_commit_node(struct repository *r)
|
|
{
|
|
struct commit *c = alloc_node(r->parsed_objects->commit_state, sizeof(struct commit));
|
|
init_commit_node(r, c);
|
|
return c;
|
|
}
|
|
|
|
static void report(const char *name, unsigned int count, size_t size)
|
|
{
|
|
fprintf(stderr, "%10s: %8u (%"PRIuMAX" kB)\n",
|
|
name, count, (uintmax_t) size);
|
|
}
|
|
|
|
#define REPORT(name, type) \
|
|
report(#name, r->parsed_objects->name##_state->count, \
|
|
r->parsed_objects->name##_state->count * sizeof(type) >> 10)
|
|
|
|
void alloc_report(struct repository *r)
|
|
{
|
|
REPORT(blob, struct blob);
|
|
REPORT(tree, struct tree);
|
|
REPORT(commit, struct commit);
|
|
REPORT(tag, struct tag);
|
|
REPORT(object, union any_object);
|
|
}
|