mirror of
https://github.com/git/git
synced 2024-10-30 04:01:21 +00:00
d1cbe1e6d8
hash.h depends upon and includes repository.h, due to the definition and use of the_hash_algo (defined as the_repository->hash_algo). However, most headers trying to include hash.h are only interested in the layout of the structs like object_id. Move the parts of hash.h that do not depend upon repository.h into a new file hash-ll.h (the "low level" parts of hash.h), and adjust other files to use this new header where the convenience inline functions aren't needed. This allows hash.h and object.h to be fairly small, minimal headers. It also exposes a lot of hidden dependencies on both path.h (which was brought in by repository.h) and repository.h (which was previously implicitly brought in by object.h), so also adjust other files to be more explicit about what they depend upon. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
123 lines
2.7 KiB
C
123 lines
2.7 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 "git-compat-util.h"
|
|
#include "object.h"
|
|
#include "blob.h"
|
|
#include "tree.h"
|
|
#include "commit.h"
|
|
#include "repository.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 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--;
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
static unsigned int parsed_commits_count;
|
|
return parsed_commits_count++;
|
|
}
|
|
|
|
void init_commit_node(struct commit *c)
|
|
{
|
|
c->object.type = OBJ_COMMIT;
|
|
c->index = alloc_commit_index();
|
|
}
|
|
|
|
void *alloc_commit_node(struct repository *r)
|
|
{
|
|
struct commit *c = alloc_node(r->parsed_objects->commit_state, sizeof(struct commit));
|
|
init_commit_node(c);
|
|
return c;
|
|
}
|