| /* |
| * 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; |
| } |